Introduction à Streamlit et au caching

Streamlit est une bibliothèque Python open-source permettant aux développeurs de créer des applications web interactives et conviviales pour les projets de machine learning et de science des données. Elle est conçue pour aider les scientifiques des données et les ingénieurs à transformer des scripts de données en applications web partageables en seulement quelques lignes de code, sans avoir besoin de compétences en développement front-end.

Le caching, quant à lui, est une technique utilisée en informatique pour stocker temporairement des données dans une zone de stockage temporaire, appelée cache, afin d'accélérer la récupération des données. Dans le contexte de Streamlit, le caching peut considérablement améliorer les performances de vos applications web, notamment lors de la manipulation de grands ensembles de données ou de calculs complexes.

Qu'est-ce que Streamlit ?

Streamlit est une innovation majeure dans le domaine de la science des données et du machine learning. Il vous permet de créer rapidement des applications de données interactives et robustes. Avec Streamlit, vous pouvez créer de belles applications web axées sur les données en seulement quelques lignes de code Python. Il est conçu pour gérer de grands ensembles de données et des calculs complexes, ce qui en fait un outil puissant pour les scientifiques des données et les ingénieurs en machine learning.

Qu'est-ce que le caching ?

Le caching est une technique utilisée pour stocker temporairement des données dans un cache, qui est une couche de stockage de données à grande vitesse. Le principal objectif du caching est d'augmenter la vitesse de récupération des données en réduisant la nécessité d'accéder à la couche de stockage lente sous-jacente. Lorsque les données sont demandées, le système vérifie d'abord le cache. Si les données sont trouvées, elles sont immédiatement renvoyées. Sinon, le système récupère les données à partir du stockage principal, les renvoie et les stocke également dans le cache pour les futures requêtes.

Pourquoi avez-vous besoin du caching dans Streamlit ?

Dans Streamlit, chaque fois qu'une interaction se produit dans l'application, le script entier est réexécuté du début à la fin. Bien que ce modèle simplifie le modèle de programmation, il peut entraîner des inefficacités. Par exemple, si votre script inclut une fonction chargée d'un grand ensemble de données ou effectue un calcul chronophage, vous ne voudriez pas exécuter cette fonction à chaque fois que le script est réexécuté. C'est là que le caching intervient. En utilisant le caching de Streamlit, vous pouvez vous assurer que certaines fonctions ne sont réexécutées que lorsque leurs données d'entrée changent.

Les avantages de l'utilisation du caching de Streamlit

Le caching dans Streamlit offre plusieurs avantages :

• Amélioration des performances : En stockant les résultats d'appels de fonctions coûteuses dans le cache, vous pouvez considérablement accélérer vos applications Streamlit. Cela est particulièrement bénéfique lors de la manipulation de grands ensembles de données ou de modèles de machine learning complexes qui prennent beaucoup de temps à charger ou à calculer.

• Augmentation de l'efficacité : Le caching vous permet d'éviter les calculs inutiles. Si une fonction a déjà été appelée avec les mêmes arguments, Streamlit peut récupérer le résultat à partir du cache au lieu de réexécuter la fonction.

• Amélioration de l'expérience utilisateur : Des temps de chargement plus rapides et des applications plus réactives conduisent à une meilleure expérience utilisateur. Grâce au caching, les utilisateurs n'ont pas à attendre le chargement des données ou l'achèvement des calculs à chaque interaction avec votre application.

Le mécanisme de caching de Streamlit permet aux développeurs de stocker les résultats des calculs de fonctions dans un cache, ce qui permet une récupération plus rapide des données et une amélioration des performances de l'application. Cette section expliquera comment fonctionne le caching de Streamlit, ses avantages et les défis qu'il présente.

Les défis liés à l'utilisation du caching de Streamlit

Bien que le caching soit une fonctionnalité puissante, il présente également quelques défis :

• Gestion du cache : La gestion du cache peut être délicate. Vous devez vous assurer que le cache ne consomme pas trop de mémoire et qu'il est invalide correctement lorsque les données d'entrée d'une fonction mise en cache changent.

• Débogage : Le débogage peut être plus complexe avec le caching. Si la sortie d'une fonction est lue à partir du cache, les instructions d'affichage ou les effets secondaires dans la fonction ne se produiront pas, ce qui peut rendre le débogage plus difficile.

• Persistance du cache : Par défaut, le cache de Streamlit est effacé à chaque nouvelle exécution du serveur Streamlit. Si vous avez besoin d'un caching persistant sur plusieurs exécutions, vous devrez utiliser des options de caching avancées ou des solutions de caching externes.

Fonctionnement du caching de Streamlit

Streamlit propose un décorateur, @st.cache, que vous pouvez ajouter avant une définition de fonction pour activer le caching. Lorsque vous marquez une fonction avec le décorateur @st.cache, Streamlit vérifie si cette fonction a déjà été appelée avec les mêmes données d'entrée. Si c'est le cas, Streamlit lit la sortie de la fonction à partir du cache, ce qui est beaucoup plus rapide que l'exécution de la fonction. Sinon, il exécute la fonction, stocke le résultat dans le cache et renvoie le résultat.

Voici un exemple simple de l'utilisation du caching de Streamlit :

@st.cache
def load_data():
    data = pd.read_csv('large_dataset.csv')
    return data

Dans cet exemple, la fonction load_data ne s'exécutera qu'une seule fois, quelle que soit le nombre de fois où le script est réexécuté. Le résultat est stocké dans le cache pour une utilisation future, ce qui permet de gagner du temps et des ressources de calcul.

Mécanismes de caching de Streamlit : @st.cache, st.cache_data et st.cache_resource

Streamlit propose plusieurs mécanismes de caching que vous pouvez utiliser en fonction de vos besoins. Cette section expliquera les différences entre @st.cache, st.cache_data et st.cache_resource.

@st.cache

@st.cache est un décorateur que vous pouvez ajouter avant une définition de fonction pour activer le caching. Lorsqu'une fonction marquée avec @st.cache est appelée, Streamlit vérifie si la fonction a déjà été appelée avec les mêmes données d'entrée. Si c'est le cas, Streamlit lit la sortie de la fonction à partir du cache. Sinon, il exécute la fonction, stocke le résultat dans le cache et renvoie le résultat.

Voici un exemple de l'utilisation de @st.cache :

@st.cache def load_data(): data = pd.read_csv('large_dataset.csv') return data

Dans cet exemple, la fonction `load_data` ne s'exécutera qu'une seule fois, quelle que soit le nombre de fois que le script est relancé. Le résultat est stocké dans le cache pour une utilisation ultérieure.

#### st.cache_data

Le `st.cache_data` est un décorateur utilisé pour mettre en cache les fonctions qui renvoient des données telles que des transformations de dataframe, des requêtes de base de données ou des inférences d'apprentissage automatique. Les objets mis en cache sont stockés sous forme « pickled », ce qui signifie que la valeur de retour d'une fonction mise en cache doit pouvoir être picklée. Chaque appelant de la fonction mise en cache obtient sa propre copie des données mises en cache. Vous pouvez vider le cache d'une fonction avec `func.clear()` ou vider le cache entier avec `st.cache_data.clear()`. Si vous devez mettre en cache des ressources globales, vous pouvez utiliser `st.cache_resource` à la place.

La signature de la fonction est la suivante:

```python
st.cache_data(func=None, *, ttl, max_entries, show_spinner, persist, experimental_allow_widgets, hash_funcs=None)

Les paramètres incluent la fonction à mettre en cache, le temps maximum de conservation d'une entrée dans le cache, le nombre maximal d'entrées à conserver dans le cache, s'il faut activer le spinner, l'emplacement pour persister les données mises en cache, s'il faut autoriser les widgets à être utilisés dans la fonction mise en cache, et une correspondance des types ou des noms entièrement qualifiés vers des fonctions de hachage.

st.cache_resource

Le st.cache_resource est un décorateur utilisé pour mettre en cache les fonctions qui renvoient des ressources globales telles que des connexions de base de données ou des modèles d'apprentissage automatique. Les objets mis en cache sont partagés entre tous les utilisateurs, sessions et redémarrages. Ils doivent être thread-safe car ils peuvent être accessibles à partir de plusieurs threads simultanément. Si la sécurité des threads pose un problème, vous pouvez utiliser st.session_state pour stocker les ressources par session. Vous pouvez vider le cache d'une fonction avec func.clear() ou vider le cache entier avec st.cache_resource.clear().

La signature de la fonction est la suivante:

st.cache_resource(func, *, ttl, max_entries, show_spinner, validate, experimental_allow_widgets, hash_funcs=None)

Les paramètres incluent la fonction qui crée la ressource mise en cache, le temps maximum de conservation d'une entrée dans le cache, le nombre maximal d'entrées à conserver dans le cache, s'il faut activer le spinner, une fonction de validation facultative pour les données mises en cache, s'il faut autoriser les widgets à être utilisés dans la fonction mise en cache, et une correspondance des types ou des noms entièrement qualifiés vers des fonctions de hachage.

Mise en cache avec Streamlit en pratique: cas d'utilisation et exemples

La mise en cache de Streamlit peut être utilisée dans divers scénarios pour améliorer les performances de vos applications de données. Cette section explore certains cas d'utilisation courants et fournit des exemples de mise en œuvre de la mise en cache dans Streamlit.

Mise en cache des modèles d'apprentissage automatique

Le chargement des modèles d'apprentissage automatique peut être long, en particulier pour les modèles volumineux. En mettant en cache le processus de chargement du modèle, vous pouvez accélérer considérablement vos applications Streamlit. Voici un exemple:

@st.cache(allow_output_mutation=True)
def load_model():
    model = load_your_model_here()  # remplacez par votre code de chargement de modèle
    return model

Dans cet exemple, l'option allow_output_mutation=True est utilisée car les modèles d'apprentissage automatique contiennent souvent des types non hachables, qui ne sont pas compatibles avec la mise en cache par défaut de Streamlit.

Mise en cache de la visualisation de données

La visualisation de données peut être un processus intensif en calcul, en particulier lorsqu'il s'agit de grands ensembles de données. En mettant en cache les résultats de vos fonctions de visualisation de données, vous pouvez rendre vos applications Streamlit plus réactives. Voici un exemple:

@st.cache
def create_plot(data):
    fig = perform_expensive_plotting_here(data)  # remplacez par votre code de traçage
    return fig

Dans cet exemple, la fonction create_plot ne sera réexécutée que si l'entrée data change, ce qui permet de gagner du temps et des ressources de calcul.

Mise en cache des appels d'API

Si votre application Streamlit effectue des appels d'API, la mise en cache peut vous aider à éviter de dépasser les limites de taux d'appel d'API et à améliorer les performances de votre application en réduisant le nombre d'appels d'API. Voici un exemple:

@st.cache
def fetch_data(api_url):
    response = requests.get(api_url)
    return response.json()

Dans cet exemple, la fonction fetch_data ne fera un appel d'API que si elle est appelée avec une nouvelle api_url. Sinon, elle renverra la réponse mise en cache.

Mise en cache des résultats de l'exploration de sites web

Le parcours de sites web peut être un processus lent et le parcours répété du même site peut entraîner le blocage de votre adresse IP. En mettant en cache les résultats de vos fonctions de parcours de sites web, vous pouvez éviter les demandes réseau inutiles. Voici un exemple:

@st.cache
def scrape_website(url):
    data = perform_web_scraping_here(url)  # remplacez par votre code de parcours de site web
   
    return data

Dans cet exemple, la fonction scrape_website ne parcourra le site web que si elle est appelée avec une nouvelle url. Sinon, elle renverra les données mises en cache.

Bonnes pratiques de mise en cache avec Streamlit

Lors de l'utilisation de la mise en cache de Streamlit, il y a plusieurs bonnes pratiques à garder à l'esprit:

• Utilisez @st.cache avec parcimonie: Bien que la mise en cache puisse améliorer considérablement les performances de votre application, elle peut également consommer beaucoup de mémoire si elle n'est pas utilisée avec précaution. Utilisez @st.cache uniquement pour les fonctions qui effectuent des calculs coûteux ou qui chargent de grands ensembles de données.

• Évitez les effets secondaires dans les fonctions mises en cache: Les fonctions marquées avec @st.cache ne doivent pas avoir d'effets secondaires. Les effets secondaires sont des modifications qu'une fonction apporte à son environnement, telles que la modification d'une variable globale ou l'écriture dans un fichier. Si une fonction avec des effets secondaires est mise en cache, les effets secondaires ne se produiront que la première fois que la fonction est appelée.

• Soyez attentif aux arguments mutables: Si une fonction mise en cache prend des arguments mutables, tels que des listes ou des dictionnaires, sachez que Streamlit utilise les valeurs initiales de ces arguments pour identifier le résultat mis en cache. Si vous modifiez les arguments après avoir appelé la fonction, Streamlit ne reconnaîtra pas les modifications et renverra le résultat mis en cache.

• Considérez d'utiliser allow_output_mutation=True pour les sorties non hashables: Par défaut, le cache de Streamlit exige que les sorties de la fonction soient hashables. Si votre fonction renvoie une sortie non hashable, telle qu'un modèle d'apprentissage automatique, vous pouvez utiliser l'option allow_output_mutation=True pour contourner cette exigence.

Bonus: Les widgets interactifs de Streamlit

Les widgets interactifs de Streamlit sont une fonctionnalité clé qui le distingue des autres outils de visualisation de données. Ces widgets permettent aux utilisateurs d'interagir avec vos applications Streamlit, ce qui leur permet de contrôler le comportement de votre application et d'interagir avec vos données en temps réel.

Curseur

Le widget curseur permet aux utilisateurs de sélectionner une valeur ou une plage de valeurs en faisant glisser un curseur le long d'une échelle horizontale. Cela est utile pour permettre aux utilisateurs de contrôler les paramètres numériques de votre application.

âge = st.slider('Quel âge avez-vous?', 0, 130, 25)
st.write("J'ai ", âge, 'ans')

Dans cet exemple, le curseur permet aux utilisateurs de sélectionner un âge entre 0 et 130, avec une valeur par défaut de 25.

Case à cocher

Le widget case à cocher permet aux utilisateurs d'activer ou de désactiver une option binaire. Cela est utile pour permettre aux utilisateurs d'activer ou de désactiver certaines fonctionnalités de votre application.

d'accord = st.checkbox('Je suis d'accord')
if d'accord:
    st.write('Super !')

Dans cet exemple, la case à cocher permet aux utilisateurs d'être d'accord ou pas avec une affirmation. Si l'utilisateur coche la case, l'application affiche le message "Super !".

Saisie de texte

Le widget de saisie de texte permet aux utilisateurs d'entrer une chaîne de texte. Cela est utile pour permettre aux utilisateurs d'entrer des données textuelles dans votre application.

titre = st.text_input('Titre du film', 'La vie de Brian')
st.write('Le titre du film actuel est', titre)

Dans cet exemple, la saisie de texte permet aux utilisateurs d'entrer un titre de film.

Avez-vous entendu parler de cet outil incroyable d'analyse de données et de visualisation de données, qui transforme votre application Streamlit en Tableau ?

PyGWalker (opens in a new tab) est une bibliothèque Python qui vous aide à intégrer facilement une interface utilisateur similaire à Tableau dans votre propre application Streamlit sans effort. Regardez cette vidéo incroyable produite par Sven de Coding is Fun (opens in a new tab) qui présente les étapes détaillées pour enrichir votre application Streamlit avec cette puissante bibliothèque de visualisation de données en Python !

Un grand merci à Sven et sa grande contribution (opens in a new tab) à la communauté de PyGWalker !

De plus, vous pouvez également consulter la page GitHub de PyGWalker (opens in a new tab) pour plus d'exemples de PyGWalker.

Conclusion

Le mécanisme de mise en cache de Streamlit est un outil puissant qui peut accélérer considérablement votre application en évitant les calculs inutiles. En comprenant comment fonctionne la mise en cache de Streamlit et comment l'utiliser efficacement, vous pouvez créer des applications plus efficaces et réactives. Que vous mettiez en cache des transformations de données, des modèles d'apprentissage automatique ou des appels API, la mise en cache de Streamlit peut vous aider à offrir une expérience utilisateur plus fluide et plus interactive.

N'oubliez pas que même si la mise en cache peut améliorer les performances, ce n'est pas toujours la bonne solution. Pensez toujours aux compromis et assurez-vous de tester votre application en profondeur pour vous assurer que la mise en cache améliore les performances de votre application sans introduire de comportement inattendu.

Les widgets interactifs de Streamlit, tels que les curseurs, les cases à cocher et les saisies de texte, permettent aux utilisateurs d'interagir avec votre application et de contrôler son comportement. En combinant ces widgets avec le mécanisme de mise en cache de Streamlit, vous pouvez créer des applications de données puissantes et réactives.

En fin de compte, la simplicité, la flexibilité et l'accent mis sur les données et l'apprentissage automatique font de Streamlit un excellent choix pour la création d'applications de données. Avec son mécanisme de mise en cache et ses widgets interactifs, vous pouvez créer des applications qui sont non seulement puissantes et efficaces, mais aussi interactives et captivantes.

Avez-vous entendu parler de cet outil incroyable d'analyse de données et de visualisation de données, qui transforme votre application Streamlit en Tableau ?

PyGWalker (opens in a new tab) est une bibliothèque Python qui vous aide à intégrer facilement une interface utilisateur similaire à Tableau dans votre propre application Streamlit sans effort.

(opens in a new tab)

Questions fréquemment posées

Comment fonctionne la mise en cache de Streamlit ?

Le mécanisme de mise en cache de Streamlit fonctionne en stockant les résultats des appels de fonction dans un cache. Lorsqu'une fonction décorée par @st.cache est appelée, Streamlit vérifie si la fonction a été appelée avec les mêmes entrées auparavant. Si c'est le cas, Streamlit peut éviter d'exécuter la fonction et utiliser à la place le résultat mis en cache. Cela peut considérablement accélérer votre application en évitant les calculs coûteux, tels que le chargement de données ou l'exécution d'un modèle d'apprentissage automatique.

Quelles sont les limitations de la mise en cache de Streamlit ?

Bien que le mécanisme de mise en cache de Streamlit soit puissant, il présente quelques limitations. Par exemple, la valeur de retour d'une fonction mise en cache doit être pickleable, c'est-à-dire qu'elle peut être sérialisée et désérialisée à l'aide du module pickle de Python. Cela signifie que tous les objets Python ne peuvent pas être renvoyés par une fonction mise en cache. De plus, les fonctions mises en cache ne doivent pas avoir d'effets secondaires, car ils ne seront exécutés qu'à la première fois où la fonction est appelée.

Comment vider le cache dans Streamlit ?

Vous pouvez vider le cache dans Streamlit en utilisant la fonction st.cache.clear(). Cela supprimera toutes les entrées du cache. Si vous souhaitez vider le cache pour une fonction spécifique, vous pouvez utiliser la méthode func.clear(), où func est la fonction mise en cache.

Où se trouve la mise en cache de Streamlit ? Le cache de Streamlit est stocké en mémoire par défaut. Cela signifie que le cache est effacé à chaque redémarrage de votre application Streamlit. Cependant, vous pouvez configurer Streamlit pour persister le cache sur le disque en définissant le paramètre persist du décorateur @st.cache sur True.