Streamlit-ը պարզ դեմո հավելվածների համար. առավելություններ և թերություններ
Երբևէ հանդիպե՞լ եք մեքենայական ուսուցման մոդելի դեմոյի՝ հղկված գրաֆիկական ինտերֆեյսով։ Հավանաբար այն կառուցված է Streamlit-ով։ Շարունակեք կարդալ՝ այս ֆրեյմվորքի մասին ավելին իմանալու համար։
Ի՞նչ է Streamlit-ը
Երբևէ հանդիպե՞լ եք մեքենայական ուսուցման մոդելի դեմոյի՝ հղկված գրաֆիկական ինտերֆեյսով։ Շատ հավանական է՝ այն կառուցված է Streamlit ֆրեյմվորքով։ Streamlit-ը բաց կոդով Python ֆրեյմվորք է արագ նախատիպավորման, վիզուալիզացիաների և դաշբորդների ստեղծման համար, և այն չի պահանջում ֆրոնտենդ տեխնոլոգիաների, ինչպիսիք են JS-ը կամ HTML-ը, որևէ իմացություն։ Մի բուռ կոդի տող բավական է դինամիկ, գեղեցիկ հավելվածներ կառուցելու համար, որոնցում օգտատերերը կարող են տվյալներ մուտքագրել և արդյունքները տեսնել իրական ժամանակում։ Երբ Streamlit հավելվածն աշխատում է, Python կոդը կատարվում է և ստեղծում է HTML, CSS և JavaScript, որոնք անհրաժեշտ են հավելվածը բրաուզերում արտապատկերելու համար։
Ինչի համար է այն օգտագործվում
Նրա հիմնական նպատակը պարզ վեբ հավելվածների կառուցումն է, որոնք ցուցադրում են, թե ինչպես են աշխատում մեքենայական ուսուցման մոդելները կամ ալգորիթմները, կամ ներկայացնում են տվյալներ։ Այն գալիս է պարամետրեր մուտքագրելու և տարբեր տեսակի տվյալներ՝ տեքստից և պատկերներից մինչև աուդիո, ցուցադրելու համար պատրաստի վիջեթների բավականին մեծ քանակով։ Այս տարրերն իրականացված են JS-ով, բայց տրամադրում են պարզ Python ինտերֆեյս։ Քանի որ այն շատ հեշտ է օգտագործել, հարմար է արագ նախատիպավորման և դեմո հավելվածների կառուցման համար։
Այս հոդվածում շոշափված թեմաների մեծ մասը կիրառվել է դեմո հավելվածում։
Առավելություններ
Ահա, թե ինչն ենք մենք գնահատում այս ֆրեյմվորքում։
Session state
Քանի որ ֆրեյմվորքը ռեակտիվ է ըստ դիզայնի, հավելվածը վերագործարկվում է ամեն անգամ, երբ նրա վիճակը փոխվում է և տեսարանը պետք է թարմացվի։ Session state-ը գոյություն ունի հավելվածի վիճակը այս վերագործարկումների միջև պահպանելու համար։ Այդպես կառուցված հավելվածը պտտվում է session state-ից արժեքներ կարդալու և նրա մեջ գրելու շուրջ, ինչը այն դարձնում է այս ֆրեյմվորքով գրված յուրաքանչյուր հավելվածի կենտրոնական մասը։ Session state-ը thread-safe է. յուրաքանչյուր սեսիա ունի իր սեփականը, ուստի մի քանի օգտատերեր իրար չեն խանգարի հավելվածի վիճակում։ Այն փաթեթի մակարդակի գլոբալ փոփոխական է՝ սովորական Python բառարանի նույն ինտերֆեյսով։
Վիջեթների ռեակտիվ վիճակներ
Վիջեթների, օրինակ՝ checkbox-ի, վիճակը կարդալն ու թարմացնելը պարզ է։ Պետք է միայն session state բառարանում սահմանել բանալի, որի տակ կպահվի վիջեթի վիճակը, ուրիշ ոչինչ։ Այստեղից կարող ենք անցնել հավելվածի տրամաբանությունը գրելուն։
view.py
import streamlit as st
from demo_streamlit.callbacks import sample_index_callback
from demo_streamlit.load_data import load_dataset
from demo_streamlit.settings import Settings
def sidebar_view() -> None:
"""Draw side bar."""
samples = load_dataset()
st.sidebar.selectbox(
"Select sample index:",
options=list(range(0, len(samples))),
key=Settings.selected_sample_index,
on_change=sample_index_callback,
)
Վիջեթի արժեքը վերցվում է նրա բանալիով.
app_state.py
from dataclasses import dataclass
import streamlit as st
from demo_streamlit.settings import Settings
@dataclass
class AppState:
"""An app state model."""
selected_sample_index: int
"""Selected sample index."""
message: str
"""UI message."""
def get_app_state() -> AppState:
"""Get AppState dataclass from session state."""
return AppState(
selected_sample_index=int(
st.session_state.get(Settings.selected_sample_index, 0)
),
message=st.session_state.get(Settings.message, ""),
)
Thread-safe սինգլթոններ և քեշ
Քեշը հաճախ օգտագործվող հնարավորություն է, որը թույլ է տալիս օպտիմալացնել ժամանակատար գործողությունները, երբ հավելվածի տեսարանը թարմացվում է։ Ֆրեյմվորքում ներկառուցված քեշավորման մեխանիզմը շատ հեշտ է օգտագործել։ Այն հիմնվում է @st.cache դեկորատորի վրա, որտեղ կարելի է սահմանել, օրինակ՝ time to live պարամետրը և հեշ ֆունկցիաներ հատուկ օբյեկտների համար։ Քեշը հաշվի է առնում արգումենտները, ֆունկցիայի մարմինը՝ իր կանչած բոլոր ֆունկցիաների հետ միասին, և ֆունկցիայի օգտագործած ցանկացած արտաքին փոփոխական։ Քանի որ ֆրեյմվորքը ռեակտիվ է և ամեն վիճակի փոփոխության ժամանակ վերագծում է UI-ը, քեշավորումն անփոխարինելի է հավելվածը ողջամտորեն արագ և արձագանքող պահելու համար։
Ստորև բերված կոդը սահմանում է ֆունկցիա, որը վերադարձնում է տվյալների բազայում պահվող օբյեկտները, որոնք համապատասխանում են հարցմանը։ Քանի որ այն կատարվում է որոշ ժամանակ, այն օպտիմալացվել է քեշավորման մեխանիզմով, և TTL պարամետրը սահմանվել է 10 րոպե։ Այն օբյեկտների համար, որոնք ֆրեյմվորքը ինքնուրույն չի կարող հեշավորել, տրամադրվել են հատուկ հեշ ֆունկցիաներ։ Բարդ օբյեկտների համար դրանք վերադարձնում են None, ինչը այդ օբյեկտները դուրս է թողնում հեշի հաշվարկից։
database.py
@st.cache(
hash_funcs={
Collection: lambda _: None,
database.Database: lambda _: None,
MongoClient: lambda _: None,
},
ttl=600, # TTL value in seconds
)
def list_items(
self,
query: dict[str, Any] | None = None,
) -> list[dict[str, Any]]:
if query is None:
query = {}
items: list[dict[str, Any]] = [item for item in self._collection.find(query, sort=[("timestamp_created", -1)])]
return items
Վիջեթների ճկուն callback-ներ
Ֆրեյմվորքը շատ ճկուն է վիջեթների իրադարձությունների համար callback-ներ սահմանելիս։ Գոյություն ունեն ընդամենը մի քանի իրադարձություններ, բայց դրանք ծածկում են կարիքների մեծ մասը՝ on_click և on_change։ Վիջեթ կառուցելիս կարող ենք on_click-ին կամ on_change-ին փոխանցել ֆունկցիա, որը կկանչվի իրադարձության հետ։ Կարող ենք նաև ցանկացած պարամետրեր փոխանցել tuple-ի տեսքով՝ args արգումենտի միջոցով։
callback.py
import logging
from typing import Any
import streamlit as st
logger = logging.getLogger(__name__)
def button_callback(index: str, headers: dict[str, Any] | None) -> None:
"""Button on_click callback."""
logger.info( # pylint: disable = (logging-fstring-interpolation)
f"Passed arguments: ({index}, {headers})."
)
view.py
import streamlit as st
from streamlit.web.server.websocket_headers import _get_websocket_headers
from demo_streamlit.callbacks import button_callback
from demo_streamlit.settings import Settings
def sidebar_view() -> None:
"""Draw side bar."""
headers: dict[str, str] | None = _get_websocket_headers()
if headers:
with st.sidebar.expander("HTTP header"):
st.json(headers)
st.sidebar.button(
label="Log parameters to terminal",
on_click=button_callback,
args=(
st.session_state.get(Settings.selected_sample_index, 0),
headers,
),
)
Կոճակը սեղմելուց հետո տերմինալը ցույց տվեց հետևյալ ելքը.
Query params՝ հավելվածի վիճակը URL-ում պահելու համար
Երբ հավելվածն օգտագործում են մի քանի մարդ, նրանք կարող են ցանկանալ իրար հետ կիսվել նրա կոնֆիգուրացիայով։ Հենց դրա համար է ֆրեյմվորքի query_params հնարավորությունը։ st.experimental_set_query_params ֆունկցիան ընդունում է բառարան, որը վերածվում է URL-ի GET պարամետրերի։ Նույն կերպ st.experimental_set_query_params ֆունկցիան URL-ից կարդում է պարամետրերի բառարան։ Սա հնարավորություն է տալիս ինչ-որ մեկին ուղարկել URL՝ պահված պարամետրերով, որպեսզի հավելվածը բացելիս նա տեսնի ճիշտ նույն տեսքը։ Խնդիրն աջակցվող տվյալների ձևաչափն է, որը պետք է լինի dict[str, list[str]]։
Python դեկորատորներ վիճակի թարմացումների համար
Դեկորատորները արժե դիտարկել անընդհատ կրկնվող գործողությունների համար։ Օրինակ՝ query_params-ի թարմացումը կարելի է փաթեթավորել դեկորատորի մեջ և կցել յուրաքանչյուր callback-ին, որը արձագանքում է վիջեթների վիճակի փոփոխություններին։
query_params.py
from functools import wraps
import streamlit as st
def update_query_params() -> None:
"""Updates the URL query params."""
query_params: dict[str, list[str]] = dict()
query_params["text_input"] = [st.session_state.get("text_input", "")]
query_params["checkbox_state"] = [str(st.session_state.get("checkbox_state", False))]
st.experimental_set_query_params(**query_params)
def refresh_query_params(f):
"""Updates the URL query params after every app state change."""
@wraps(f)
def wrapper(*args, **kwargs):
retval = f(*args, **kwargs)
update_query_params()
return retval
return wrapper
callback.py
from query_params import refresh_query_params
@refresh_query_params
def checbox_callback() -> None:
...
@refresh_query_params
def text_input_callback() -> None:
...
Մշակման սերվերի ռեժիմ՝ կոդի փոփոխությունների մոնիթորինգով
Սա պարզապես հարմար է։ Կարիք չկա հավելվածը վերագործարկել սկզբնական կոդում յուրաքանչյուր փոփոխությունից հետո։ Լռելյայն streamlit-ը հավելվածները գործարկում է մշակողի ռեժիմով, որը հետևում է սկզբնական կոդի փոփոխություններին։ Յուրաքանչյուր փոփոխություն հայտնաբերվում է, և հավելվածն անմիջապես ճշգրտում է իր վարքը։
HTTP հարցման header-ների հասանելիություն
1.14.0 տարբերակից սկսած՝ կարելի է կարդալ հավելվածին հասած հում HTTP header-ը։ Սա օգտակար է, երբ HTTP header-ներից պետք է հանել կոնկրետ տեղեկություն, օրինակ՝ Google Cloud-ով նույնականացված օգտատիրոջ ID-ն/էլ. հասցեն.
import streamlit as st
from streamlit.web.server.websocket_headers import _get_websocket_headers
headers = _get_websocket_headers()
access_token = headers.get("X-Access-Token")
if access_token is not None:
# authenticate the user or whatever
...
Տեղակայում
Հավելվածի տեղակայումը շատ հեշտ է, և փաստաթղթերը մանրամասն ներկայացնում են այն։ Բացատրվում է, թե ինչպես տեղակայել Docker-ով, kubernetes-ով կամ Streamlit Cloud կոնտեյներներով։ Յուրաքանչյուր ուղեցույց ուղեկցվում է կոդի օրինակներով, այնպես որ օգտատերը քայլ առ քայլ անցնում է ամբողջ գործընթացը։
Streamlit Cloud-ում հավելված գործարկելու համար անհրաժեշտ է միայն հղում GitHub ռեպոզիտորիային։ Մի քանի սեղմումից հետո ստանում ենք հանրային URL, որտեղ հասանելի է մեր աշխատող հավելվածը։
Թերություններ
Ստորև ներկայացված են ֆրեյմվորքի թույլ կողմերը, որոնք արժե հաշվի առնել հավելված նախագծելիս։
Տեսարանը վերագծվում է ամեն անգամ, երբ վիճակը փոխվում է
Ինչպես նշվել է, UI-ի վիճակի ամեն փոփոխություն հավելվածին ստիպում է իր կոդը կատարել հենց սկզբից՝ հավելվածի ամբողջ վիճակը պահելով session state-ում։ Երբ վիջեթների վիճակները հաճախ են փոխվում, հավելվածը կարող է նյարդայնացնող հաճախությամբ թարմացվել, ինչը զգալի ուշացում է ավելացնում։ Այս վարքը ստիպում է հավելվածն այնպես նախագծել, որ հնարավորինս շատ դանդաղ ֆունկցիաներ քեշավորված լինեն, բայց հավելվածների որոշ տեսակների համար դա բավարար չէ։
Կոնտեյներների ներդրում չկա
Տեսքերը (views) չի կարելի ներդնել մեկը մյուսի մեջ, ինչը լրջորեն սահմանափակում է հավելվածի դասավորության նախագծումը։ Սա խնդիր է դառնում ավելի բարդ տեսքերում կամ երբ ուզում ենք համեմատելու համար կողք կողքի ցուցադրել երկու բարդ օբյեկտ։ Այս սահմանափակման պատճառով պետք է լուծումներ գտնել, որոնք կարող են ավելի քիչ հարմար լինել։
Session state՝ միայն պարզ key-value զույգերով
Session state-ը շատ լավ է աշխատում պարզ key-value զույգերի համար, ինչպիսին է վիջեթների վիճակի պահպանումը։ Սակայն իրական հավելվածներն ավելի հաճախ հենվում են բարդ օբյեկտների վրա, որոնք պահում են ամբողջ հավելվածի վիճակը։ Այդպես մեկ օբյեկտը ներկայացնում է ամբողջ հավելվածը, և նրա դասի դաշտերի տիպերը կարելի է պարտադրել։ Ցավոք, ֆրեյմվորքը ներկայումս դա չի աջակցում։ Այս արդյունքին հասնելու համար պետք է գրել երկու ֆունկցիա, որոնք դասը բեռնում/պահպանում են session state-ից/session state-ում։
app_state.py
import streamlit as st
from dataclasses import dataclass
@dataclass
class AppState:
checkbox_state: bool
text_input: str
def load_app_state() -> AppState:
return AppState(
checkbox_state=st.session_state.get("checkbox_state", False),
text_input=st.session_state.get("text_input", ""),
)
def save_app_state(state: AppState) -> None:
st.session_state["checkbox_state"] = state.checkbox_state
st.session_state["text_input"] = state.text_input
Տարրերի կրկնօրինակում կոդում՝ վիջեթները/կոնտեյներները վերաօգտագործելիս
Երկու օբյեկտ համեմատելու համար session state-ում պետք է պահել փոփոխականների հավաքածու երկուսի համար էլ։ Քանի որ session state-ը պահում է key-value զույգեր, մենք պետք է կամ մեկ բանալիի տակ պահենք տարրերի ցուցակ, կամ յուրաքանչյուր օբյեկտի համար առանձին բանալիներ սահմանենք, օրինակ՝ text_input_1 և text_input_2։ Սա նրբագեղ չէ և սխալների հավանականությունը մեծացնում է։
Session state-ից տարրերը տիպավորելու անհրաժեշտություն
Session state-ում պահվող օբյեկտներն ունեն չհայտարարված տիպ, ուստի չենք կարող վստահ լինել, թե ինչ օբյեկտ կստանանք հետ։ Անվտանգության համար կարող ենք կիրառել typing փաթեթի cast մեթոդը։
cast_example.py
import streamlit as st
from typing import cast, Any
value: list[str]
value = cast(list[str], st.session_state["key"])
Եզրակացություն
Streamlit-ը հիանալի ֆրեյմվորք է պարզ դեմո հավելվածներ կառուցելու համար։ Երբ հավելվածի վիճակը հաճախ է փոխվում, տեսարանը ամեն փոփոխությունից հետո զրոյից վերագծելը կարող է հանգեցնել արտադրողականության և լատենտության խնդիրների։ Մյուս սահմանափակումն այն է, որ կոնտեյներները, օրինակ՝ սյունակը, չեն կարող ներդրվել մեկը մյուսի մեջ, ինչը նեղացնում է էջի դասավորության տարբերակները։
Ֆրեյմվորքի առաջարկած հնարավորությունները, ներառյալ session state-ը, քեշը և վիջեթների callback-ները, թույլ են տալիս արագ կառուցել հավելվածի բարդ հոսքեր։
Ավելի բարդ հավելվածներում կարող եք հանդիպել սահմանափակումների, որոնք բխում են ֆրեյմվորքի կառուցվածքից։ Լավ գաղափար է կշռադատել ձեր կառուցած հավելվածի պահանջները և որոշել՝ Streamlit-ը ճիշտ ընտրությո՞ւն է։ Կան շատ համանման ֆրեյմվորքեր, որոնք տարբերվում են բարդությամբ և հնարավորություններով. դրանց համեմատությունը կարող եք գտնել այստեղ։