Un guide étape par étape pour déployer des modèles ML à l'aide de Streamlit

Publié: 2020-12-07

Table des matières

introduction

La plupart des passionnés d'apprentissage automatique s'inscrivent à certains cours et programmes pour se lancer dans l'IA et le ML. Ces cours couvrent de nombreux éléments fondamentaux et guident soigneusement les apprenants pour créer et former les modèles ML de pointe.

Mais une chose avec laquelle la plupart des débutants ont du mal est la partie déploiement. Un projet d'apprentissage automatique ne peut pas être laissé tel quel sans aucune application interactive autour de lui. Pour permettre aux utilisateurs d'interagir facilement avec le modèle ou même de présenter nos projets, nous devons les intégrer dans des applications Web, des applications Android ou une sorte de structure d'API utilisant des services cloud.

Il existe différentes façons de créer ces wrappers pour nos modèles, mais dans cet article, je vais me concentrer sur la façon dont vous pouvez utiliser Streamlit comme solution à ce problème et pourquoi je le considère comme un outil si puissant.

Cet article contiendra un guide étape par étape pour créer un projet ML et créer une plate-forme d'application Web à l'aide de Streamlit. Le projet que nous allons construire est un modèle de prévision des prix des maisons en Californie. Le site sera dynamique et des hyperparamètres comme le taux d'apprentissage, le nombre de neurones, etc. pourront être modifiés et expérimentés directement via l'application Web.

Si vous continuez à créer une telle application Web en utilisant des frameworks comme Flask ou Django, je suis presque certain que cela prendra beaucoup de temps pour créer d'abord cette interface utilisateur, puis il y a un autre problème d'hébergement sur un serveur afin que il peut être accessible à tous.

Et ici se pose la question principale : "Pourquoi les passionnés d'apprentissage automatique devraient-ils perdre leur temps à apprendre certains frameworks d'interface utilisateur alors qu'ils peuvent plutôt utiliser ce temps précieux pour apprendre à créer de meilleurs modèles ?"

Il y aura beaucoup de sujets abordés ici sur la façon d'utiliser Streamlit pour vos projets. N'hésitez pas à passer aux parties sur lesquelles vous souhaitez en savoir plus.

Pourquoi Streamlit ?
Construire un modèle de ML de base
Ajouter la magie en utilisant Streamlit
Déploiement de l'application Web Streamlit
Conclusion

Pourquoi Streamlit ?

Streamlit nous permet de créer très facilement et rapidement une application Web d'apprentissage automatique. Les autres moyens disponibles pour développer de tels wrappers pour les modèles ML ne sont pas très confortables.

Flask est un framework python qui permet aux utilisateurs de développer des applications Web et de les déployer en utilisant le langage python. Cela nécessite une bonne connaissance de python et nous devons également investir du temps dans son apprentissage. Même après cela, il n'est pas très facile de développer une application Web par rapport à Streamlit.

Django est un autre framework basé sur Python pour le développement Web. On peut dire que c'est une version meilleure et complexe de Flask. Il faut beaucoup de temps pour apprendre ce cadre et finalement, créer une application Web en l'utilisant n'est pas aussi rapide que nous le souhaiterions.

Tensorflow.js est un très bon moyen d'enregistrer des modèles compatibles avec les plates-formes Web, puis ces modèles peuvent être utilisés pour créer des applications Web. De nombreuses implémentations complexes de modèles ML et d'architectures de haut niveau ne sont pas encore prises en charge par Tensorflow.js. De nombreux modèles fonctionnent en Python et peuvent ne pas fonctionner en Javascript dans la bibliothèque Tensorflow.js.

Comme je l'ai dit plus tôt, nous ne devrions pas perdre notre temps à apprendre ces frameworks et plutôt apprendre à construire de bons modèles ML. Et c'est là que Streamlit entre en scène. C'est le moyen le plus simple et le plus rapide de développer des applications Web. Les applications Web créées à l'aide de Streamlit ont d'excellents éléments d'interface utilisateur et sont très faciles à utiliser.

Pour étayer mon affirmation selon laquelle Streamlit est le moyen le plus simple et le plus rapide de créer des applications Web ML, permettez-moi de partager avec vous comment j'ai découvert ce cadre. J'apprenais à construire des GAN et à les utiliser pour générer des visages artificiels, convertir des croquis en noir et blanc en croquis colorés, et de telles implémentations.

Les modèles fonctionnaient bien dans le cahier Jupyter mais je voulais le partager avec d'autres. J'ai commencé à chercher des frameworks pour créer une application et héberger le modèle, mais je ne voulais pas perdre mon temps à apprendre un autre framework car je voulais explorer d'autres implémentations GAN.

J'ai vérifié toutes les ressources alternatives dont j'ai parlé dans cet article plus tôt. Le modèle de générateur utilisé dans le projet de génération Sketch-To-Color est un peu complexe. Il s'agit d'un modèle d'architecture U-Net et vous oblige à ignorer les connexions.

En raison de sa grande complexité, je n'ai pas pu convertir le modèle final pour Javascript à l'aide de Tensorflow.js. Apprendre Flask ou Django à partir de zéro n'était pas une option pour moi, alors j'ai commencé à chercher d'autres frameworks ou bibliothèques.

C'est alors que je suis tombé sur Streamlit. Dans un article d'Adrien Treuille, il montre comment il a construit une application web étonnante pour un TL-GAN en moins de 13 lignes de code. Tout cela n'a été possible que grâce à Streamlit.

La documentation sur leur site officiel est également très précise et utile. J'ai essayé de créer une application Web Streamlit pour mon modèle Sketch to Color GANs et c'était incroyable. Je n'ai eu qu'à ajouter 12 lignes de code à mon code python existant. C'est pourquoi j'ai finalement continué à explorer Streamlit et à construire d'autres projets en l'utilisant.

Construire un modèle ML de base

Comme indiqué précédemment, nous allons examiner le problème de prévision des prix des maisons en Californie pour cet exemple. Tout d'abord, voyons comment nous construisons normalement un modèle pour cela. C'est un problème de régression.

Tout d'abord, nous allons importer les bibliothèques requises pour notre modèle ML simple. Ici, nous utiliserons TensorFlow, pandas et NumPy.

importer tensorflow en tant que tf

importer numpy en tant que np

importer des pandas en tant que pd

Maintenant, nous allons utiliser les ensembles de données de Scikit-Learn pour télécharger l'ensemble de données sur le logement en Californie.

à partir de sklearn.datasets importer fetch_california_housing

logement = fetch_california_housing()

Ensuite, nous devons diviser les données chargées en ensembles d'apprentissage, de validation et de test. Il existe de nombreuses méthodes pour le faire. Nous allons utiliser la fonction train_test_split disponible dans la librairie Scikit-Learn. L'utiliser deux fois divisera l'ensemble de données en 3 ensembles d'entraînement, de validation et de test.

depuis sklearn.model_selection importer train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(

logement.données, logement.cible

)

X_train, X_valid, y_train, y_valid = train_test_split(

X_train_full, y_train_full

)

Les données dont nous disposons contiennent les valeurs de longitude et de latitude de chaque entrée. Pour mieux visualiser cela, nous pouvons créer un nuage de points sur une carte. Pour utiliser les cartes, nous allons importer la bibliothèque Altair .

Importer altair en tant qu'alt

map_data = pd.DataFrame(

X_train,

colonnes=[

'IncMéd',

'HouseAge',

'AveRooms',

'AveBedrms',

'Population',

'AveOccup',

'latitude',

'longitude'

])

point médian = (np.average(map_data["latitude"]), np.average(map_data["longitude"]))

st.write(pdk.Deck(

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

initial_view_state={

"latitude": point médian[0],

« longitude » : milieu[1],

"zoomer": 6,

« pas » : 75,

calques=[

pdk.Layer(

"HexagonLayer",

data=map_data,

get_position=["longitude", "latitude"],

rayon=1000,

élévation_échelle=4,

élévation_range=[0, 10000],

sélectionnable=Vrai,

extrudé=Vrai,

))

Les données que nous avons actuellement avec nous ne sont pas bien traitées pour le modèle. Nous devons faire le prétraitement afin d'obtenir de meilleurs résultats. Tout d'abord, nous devrons normaliser les valeurs car la plupart des modèles d'apprentissage automatique fonctionnent mieux lorsque les données se situent dans une petite plage de valeurs. Pour cela, nous allons utiliser la classe StandardScaler de la bibliothèque sklearn.

depuis sklearn.preprocessing importer StandardScaler

scaler = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_valid = scaler.transform(X_valid)

X_test = scaler.transform(X_test)

Après avoir préparé les données, nous allons maintenant créer un modèle. Ce modèle sera un réseau de neurones avec un nombre spécifié de neurones dans la première couche d'entrée et un seul neurone dans la dernière couche car il s'agit d'un problème de régression. Ceci peut être réalisé en utilisant la bibliothèque TensorFlow.

importer tensorflow en tant que tf

modèle = tf.keras.models.Sequential([

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

tf.keras.layers.Dense(1)

])

Dans TensorFlow, nous devons compiler le modèle après l'avoir construit. Ici, nous devons mentionner la fonction de perte que nous utiliserons ainsi que l'optimiseur que nous voulons. Nous utiliserons la fonction de perte d'erreur quadratique moyenne et l'optimiseur SGD avec un taux d'apprentissage spécifique.

modèle.compile(

perte='mean_squared_error',

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

)

Tout est en place maintenant. Tout ce que nous avons à faire est de former le modèle. Dans TensorFlow, cela peut être fait en appelant simplement la méthode fit(). Nous pouvons enregistrer tous les journaux dans une variable, history .

histoire = modèle.fit(

X_train,

y_train,

époques=n_époques,

validation_data=(X_valid, y_valid)

)

Après la formation, nous pouvons également évaluer la précision et la perte de notre modèle en utilisant la méthode évalue().

évaluation = model.evaluate(X_test, y_test)

Maintenant, si nous voulons prédire les prix des maisons en utilisant ce modèle, nous pouvons simplement le faire en appelant la méthode, predict() .

X_nouveau = X_test[:3]

prédictions = model.predict(X_new)

C'est ainsi que vous pouvez créer un modèle simple de prévision du prix de l'immobilier à l'aide de TensorFlow, scikit-learn et pandas. Mais le problème, comme vous pouvez le voir, est qu'il n'y a aucun moyen de montrer ce modèle à d'autres utilisateurs où ils peuvent interagir avec lui et ce n'est qu'un modèle à l'intérieur d'un Jupyter Notebook. Alors maintenant, ajoutons un peu de magie avec Streamlit !

Lisez aussi : Idées de projets d'apprentissage automatique

Ajouter de la magie à l'aide de Streamlit

Pour créer une application Web Machine Learning, il vous suffit d'ajouter quelques lignes de code pour les appels de fonction Streamlit et c'est tout. Vous n'avez pas besoin de HTML, CSS ou Javascript. Juste du python pur !

Oui, vous l'avez lu correctement. Vous n'avez pas à vous soucier de quoi que ce soit d'autre. Installez simplement Streamlit sur votre système et vous serez prêt à partir. Utilisez la commande suivante dans vos terminaux :

pip installer streamlit

Vous pouvez utiliser la commande suivante pour explorer dans leur application hello world. C'est un bon exemple de l'apparence des applications Web avec Streamlit. :

bonjour

Après avoir installé Streamlit localement et ajouté la ligne magique au code, il vous suffit d'exécuter la commande suivante pour exécuter l'application localement :

streamlit exécuter file_name.py

Donc, la question est maintenant : "Quelles sont ces lignes de code magiques ?" Ils sont assez simples. J'expliquerai d'abord les fonctions de base utilisées dans Streamlit, puis je montrerai le code afin que vous puissiez le relier directement à l'exemple.

Avant toute chose, nous allons importer la librairie streamlit en utilisant la ligne de code suivante :

importer streamlit en tant que st

La première caractéristique importante est que vous pouvez simplement taper n'importe quoi dans les 3 guillemets doubles, cela montre simplement le texte tel qu'il est sur l'application Web. Il prend en charge la syntaxe du langage Markdown. Vous pouvez donc faire beaucoup de choses comme des en-têtes, des puces, des tableaux et bien plus encore. Vous pouvez également utiliser la fonction st.write() au lieu de cette notation. Il a la même fonctionnalité.

Vient ensuite la fonction with st.echo(): . Cela exécute essentiellement le code python qui y est écrit, puis il l'affiche également sur l'application Web. De cette façon, nous pouvons créer une application Web qui montre comment elle a été créée.

st.empty() est une zone réservée pour du contenu dynamique ultérieurement.

st.spinner() affiche un élément de chargement lorsqu'il y a un certain retard dans l'exécution d'un morceau de code.

st.success() affiche un message en vert. Cela a un excellent aspect de conception des dialogues de réussite.

st.sidebar() affiche le contenu dans une barre latérale à gauche par défaut.

st.sidebar.slider() fournit un curseur dans la barre latérale pour choisir des valeurs dans une plage de nombres donnés. st.sidebar.selectbox() vous permet de sélectionner une valeur dans la liste donnée et Streamlit contient de nombreuses autres fonctions et fonctionnalités merveilleuses. Certaines des fonctionnalités sont les suivantes :

Changements en direct lorsque vous enregistrez le fichier
Relancez l'application en appuyant simplement sur R sur le clavier
Un cache vide en appuyant simplement sur C sur le clavier
Enregistrez l'application Web et enregistrez un fichier vidéo localement pour le partager avec tout le monde

…Et beaucoup plus

Doit lire : Carrière dans l'apprentissage automatique

Le code

importer streamlit en tant que st

importer altair en tant qu'alt

importer pydeck en tant que pdk

train_area = st.vide()

"""

# Prix des logements en Californie

Il s'agit de l'ensemble de données sur les prix des logements en Californie, qui contient des données tirées du recensement américain de 1990. Le tableau suivant fournit des descriptions, des plages de données et des types de données pour chaque entité de l'ensemble de données.

## Voyons d'abord les importations
"""
avec st.echo() :
importer tensorflow en tant que tf
importer numpy en tant que np
importer des pandas en tant que pd
"""
## Chargement du jeu de données
Nous utiliserons le module de jeu de données de scikit-learn pour diriger les données qui sont déjà nettoyées pour nous et qui n'ont que les caractéristiques numériques.
"""
avec st.echo() :
à partir de sklearn.datasets importer fetch_california_housing
logement = fetch_california_housing()
"""
Cela chargera toutes les données dans la variable "housing" comme vous pouvez le voir ci-dessous
"""
st.subheader('Fonctionnalités d'entrée')
logement.données
st.subheader('Libellés de sortie')
logement.cible
"""
## Diviser les données en ensembles Train, Test et Dev
C'est l'une des choses les plus importantes au début de toute solution d'apprentissage automatique, car le résultat de tout modèle peut fortement dépendre de la manière dont vous avez distribué les données dans ces ensembles.
Heureusement pour nous, nous avons scikit-learn à la rescousse où c'est devenu aussi simple que 2 lignes de code.
"""
avec st.echo() :
depuis sklearn.model_selection importer train_test_split
X_train_full, X_test, y_train_full, y_test = train_test_split(
logement.données, logement.cible
)
X_train, X_valid, y_train, y_valid = train_test_split(
X_train_full, y_train_full
)
"""
La fonction `train_test_split()` divise les données en 2 ensembles où l'ensemble de test représente 25 % de l'ensemble de données total. Nous avons réutilisé la même fonction sur le train_full pour le diviser en ensembles de train et de validation. 25% est un paramètre par défaut et vous pouvez le modifier selon vos besoins. Jetez-y un œil dans la [documentation de Scikit-Learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html).
## Jetez un œil aux données du train
Les colonnes représentent les données suivantes :
"""
st.write(housing.feature_names)
"""
Regardons maintenant l'emplacement des maisons en le traçant sur la carte en utilisant les valeurs de latitude et de longitude :
"""
avec st.echo() :
map_data = pd.DataFrame(
X_train,
colonnes=[
'IncMéd',
'HouseAge',
'AveRooms',
'AveBedrms',
'Population',
'AveOccup',
'latitude',
'longitude'
])
point médian = (np.average(map_data["latitude"]), np.average(map_data["longitude"]))
st.write(pdk.Deck(
map_style="mapbox://styles/mapbox/light-v9",
initial_view_state={
"latitude": point médian[0],
« longitude » : milieu[1],
"zoomer": 6,
« pas » : 75,
},
calques=[
pdk.Layer(
"HexagonLayer",
data=map_data,
get_position=["longitude", "latitude"],
rayon=1000,
élévation_échelle=4,
élévation_range=[0, 10000],
sélectionnable=Vrai,
extrudé=Vrai,
),
],
))
"""
** N'hésitez pas à zoomer ou à faire glisser tout en appuyant sur la touche ALT pour modifier l'angle de vue 3D de la carte, selon les besoins. **
## Prétraitement
Comme indiqué précédemment, cet ensemble de données est déjà bien prétraité par scikit-learn pour que nous l'utilisions directement sans nous soucier des valeurs NaN et d'autres éléments.
Cependant, nous allons mettre à l'échelle les valeurs dans des plages spécifiques en utilisant `StandardScaler` pour aider notre modèle à fonctionner efficacement.
"""
avec st.echo() :
depuis sklearn.preprocessing importer StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_valid = scaler.transform(X_valid)
X_test = scaler.transform(X_test)
"""
## Création d'un modèle
Nous allons créer un modèle séquentiel simple avec la première couche contenant 30 neurones et la fonction d'activation de RELU.
La couche suivante sera une couche de neurones uniques sans fonction d'activation car nous voulons que le modèle prédise une plage de valeurs et pas seulement des résultats binaires ou multiclasses comme les problèmes de classification.
"""
st.sidebar.title('Hyperparamètres')
n_neurons = st.sidebar.slider('Neurones', 1, 128, 30)
l_rate = st.sidebar.selectbox('Taux d'apprentissage', (0.0001, 0.001, 0.01), 1)
n_epochs = st.sidebar.number_input('Nombre d'époques', 1, 50, 20)
#Les n_neurons, l_rate et _nepochs sont les entrées prises par l'utilisateur pour former le modèle. Leurs valeurs par défaut sont également définies. La valeur par défaut pour n_neurons est 30, la valeur par défaut pour l_rate est 0,01 et la valeur par défaut pour n_epochs est 20. Ainsi, au début, le modèle aura 30 neurones dans la première couche, le taux d'apprentissage sera de 0,01 et le nombre d'époques pour pour lequel le modèle s'entraînera est de 20.
avec st.echo() :
importer tensorflow en tant que tf

modèle = tf.keras.models.Sequential([
tf.keras.layers.Dense(n_neurons, activation='relu', input_shape=X_train.shape[1:]),
tf.keras.layers.Dense(1)
])
"""
## Compilation du modèle
L'API Tensorflow keras nous fournit la fonction `model.compile()` pour attribuer les optimiseurs, la fonction de perte et quelques autres détails pour le modèle.
"""
avec st.echo() :
modèle.compile(
perte='mean_squared_error',
optimiseur=tf.keras.optimizers.SGD(l_rate)
)
"""
## Formation du modèle
Pour former le modèle, vous devez simplement appeler la fonction `fit()` sur le modèle avec un ensemble de formation et de validation et un certain nombre d'époques pour lesquelles vous souhaitez que le modèle s'entraîne.
** Essayez de jouer avec les hyperparamètres de la barre latérale sur le côté gauche et cliquez sur le bouton "Train Model" ci-dessous pour commencer la formation. **
"""
train = st.button('Train Model')
si train :
with st.spinner('Training Model…'):
avec st.echo() :
model.summary(print_fn=lambda x : st.write("{}".format(x)))
histoire = modèle.fit(
X_train,
y_train,
époques=n_époques,
validation_data=(X_valid, y_valid)
)
st.success('Formation modèle terminée !')
"""
## Performances du modèle
"""
avec st.echo() :
st.line_chart(pd.DataFrame(history.history))
"""
## Évaluation du modèle sur l'ensemble de test
Encore une fois, une autre étape importante mais facile à faire est d'évaluer votre modèle sur les données de test qu'il n'a jamais vues auparavant. N'oubliez pas que vous ne devez le faire qu'après avoir été suffisamment sûr du modèle que vous avez construit et que vous devez résister à tout réglage d'hyperparamètre après avoir évalué le modèle sur le jeu de test, car cela le rendrait simplement meilleur pour le jeu de test et encore une fois. être un problème de généralisation lorsque le modèle verra de nouvelles données dans la phase de production.
"""
avec st.echo() :
évaluation = model.evaluate(X_test, y_test)
évaluation
"""
> Cette perte sur l'ensemble de test est un peu pire que celle sur l'ensemble de validation, ce qui est comme prévu, car le modèle n'a jamais vu les images de l'ensemble de test.
"""
"""
## Prédictions à l'aide du modèle
"""
avec st.echo() :
X_nouveau = X_test[:3]
prédictions = model.predict(X_new)
"""
### prédictions
"""
prédictions
"""
### Vérité au sol
"""
y_test[:3]
C'était ça! Seulement quelques lignes de code supplémentaires et vous avez déjà créé une excellente application Web qui est belle et qui a également un contenu dynamique. Ce n'était pas si difficile, n'est-ce pas ? Essayez de créer différents projets et d'utiliser d'autres fonctions de Streamlit à partir de leur documentation. C'est assez simple et intuitif.
Lire : Apprentissage automatique avec Python
Déploiement de l'application Web Streamlit
Les applications Web Streamlit peuvent être déployées pour une utilisation directe via diverses options disponibles sur Internet. Nous pouvons les parcourir brièvement et voir comment cela peut être fait.
Avant d'aller sur d'autres plates-formes qui peuvent nous aider à déployer nos applications Web, voyons ce que Streamlit a à nous offrir. Une version de fonctionnalité très récente qu'ils ont faite est Streamlit Sharing. Cela permet aux utilisateurs de déployer leurs applications Web Streamlit en un seul clic.
Si votre code est téléchargé sur vos référentiels GitHub, vous pouvez simplement choisir le référentiel dans le tableau de bord de Streamlit et il l'hébergera automatiquement pour vous. C'est très étonnant et totalement gratuit à partir de maintenant. Il n'y a jamais eu de moyen plus simple de déployer des applications Web d'apprentissage automatique.
Heroku est une autre bonne méthode pour déployer l'application Web Streamlit. De cette façon, vous n'aurez pas à choisir de serveurs cloud, puis à y configurer des instances virtuelles. Tout est pris en charge par Heroku.
Il y a un simple inconvénient dans Heroku que sa version gratuite ne vous permettra pas d'avoir tous les packages de plus de 512 Mo dans une version gratuite. TensorFlow 2.2.0 que j'ai utilisé pour le projet est un peu plus grand que l'espace spécifié, j'ai donc dû utiliser d'autres services.
AWS (Amazon Web Services) est également un bon moyen de déployer vos applications Streamlit. C'est un peu complexe pour un débutant mais au fur et à mesure de son utilisation, il devient plus facile à mettre en place. Ils fournissent des instances EC2 gratuites pour les nouveaux utilisateurs. Vous pouvez en lancer un avec Ubuntu 18.04 ou supérieur et installer toutes les dépendances requises pour l'application.
Une fois que tout est configuré, vous pouvez exécuter l'application à l'aide de la commande - streamlit run filename.py. Ici, vous obtiendrez une URL publique qui peut être partagée avec tout le monde. Un inconvénient majeur ici est que l'application n'est pas disponible en ligne si vous arrêtez l'instance. Ainsi, une instance gratuite aura certaines limitations.
Si vous avez le code sur le référentiel GitHub, il existe un autre moyen sympa d'héberger votre application. Ce n'est pas très professionnel et légitime car l'utilisateur doit également installer Streamlit sur ses systèmes.
Si Streamlit est disponible sur le système et que vous disposez du lien vers le fichier python de l'application Streamlit, vous pouvez exécuter l'application Web en exécutant simplement la commande : streamlit run url . Vous pouvez consulter mon application localement si vous avez installé Streamlit. Utilisez la commande suivante dans vos terminaux :
course éclairée https://raw.githubusercontent.com/tejasmorkar/housing_price_prediction_aws/master/CaliforniaHousingPrices.py
Conclusion
Vous avez vu à quel point Streamlit est simple mais puissant. Je n'ai jamais rencontré un tel outil auparavant qui m'a aidé à ce point et a rendu ma vie de développement plus facile. C'est pourquoi je pense que Streamlit est un cadre impressionnant qui peut aider tout le monde à se concentrer sur les parties importantes du développement de l'apprentissage automatique et nous aider à nous concentrer davantage sur les principaux apprentissages de l'IA et du ML. Cela rend la courbe d'apprentissage beaucoup plus facile et nous permet de créer et de déployer facilement des projets de loisirs.
Une chose qui rend ce framework si simple à mettre en œuvre est leur documentation officielle. Tout ce qui est écrit dans la doc est précis et clair. Je vous suggère de parcourir les documents une fois et d'essayer de mettre en œuvre un nouveau projet. C'est le meilleur moyen de démarrer avec de nouveaux frameworks. Retrouvez la documentation officielle de Streamlit sur le lien suivant — https://docs.streamlit.io/en/stable/ target= »_blank » rel= »nofollow » .
La communauté est toujours la meilleure ressource pour apprendre des choses et trouver un problème avec nos solutions. Streamlit dispose d'un merveilleux forum de discussion où vous pouvez poser des questions concernant le processus de développement d'une application Streamlit, des doutes concernant le déploiement, les demandes de fonctionnalités, les rapports de bogues et tout ce qui pourrait vous aider à créer votre application avec succès. Rejoignez le forum de discussion sur le lien suivant — https://discuss.streamlit.io/
Si vous souhaitez en savoir plus sur l'apprentissage automatique, consultez le diplôme PG en apprentissage automatique et IA de IIIT-B & upGrad, conçu pour les professionnels en activité et offrant plus de 450 heures de formation rigoureuse, plus de 30 études de cas et missions, IIIT- Statut B Alumni, plus de 5 projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.
Quelle est la plus grande difficulté dans le déploiement d'un projet de machine learning ?
La plus grande difficulté dans le déploiement d'un projet de Machine Learning est l'incomplétude de la collecte de données. La plupart du temps, le temps et l'argent ne suffisent pas pour collecter toutes les données nécessaires à une analyse précise. Par conséquent, les données recueillies doivent être fiables et de bonne qualité. De plus, les bonnes données doivent être choisies. Le choix des données est clé dans le déploiement d'un projet.
Qu'est-ce que Streamlit dans l'apprentissage automatique ?
Streamlit est un algorithme incrémental pour l'apprentissage automatique. Il exploite le fait que l'espace de recherche des réseaux de neurones est très grand et que l'apprentissage est rapide, et il n'a donc pas besoin de parcourir tout l'espace, mais peut construire un réseau de neurones localement. StreamLit est une forme de mémoire longue à court terme utilisée pour le traitement de données séquentielles. Il s'agit d'un algorithme d'apprentissage en profondeur qui utilise les RNN pour coder les données en vecteurs de nombres. Ces vecteurs peuvent être utilisés pour représenter des données sous forme de graphiques ou de texte. Il peut également être utilisé pour générer du texte en langage naturel.
Comment déployer à l'aide de Streamlit ?
Le déploiement avec Streamlit est simple. Tout d'abord, vous devez avoir un compte Streamlit. Deuxièmement, vous avez besoin d'un logiciel capable de se déployer. Par exemple, Beanstalk, S3 ou rsync. Troisièmement, vous devez préparer votre logiciel pour le déploiement. Copiez votre application sur votre serveur Web à l'aide de rsync. Si vous déployez un nouveau site Web, le site Web est le répertoire que vous avez copié. Si vous déployez un site Web existant, le site Web téléchargé est le répertoire que vous avez copié. Sur le côté gauche de l'écran sous le