Una guía paso a paso para implementar modelos ML usando Streamlit

Introducción

La mayoría de los entusiastas del aprendizaje automático se están inscribiendo en algunos cursos y planes de estudios para comenzar con AI y ML. Estos cursos cubren una gran cantidad de cosas fundamentales y guían cuidadosamente a los alumnos para construir y entrenar los modelos ML de última generación.

Pero una cosa con la que la mayoría de los principiantes luchan es la parte de implementación. Un proyecto de aprendizaje automático no se puede dejar como está sin ninguna aplicación interactiva a su alrededor. Para permitir que los usuarios interactúen fácilmente con el modelo o incluso que muestren nuestros proyectos, debemos incluirlos en aplicaciones web, aplicaciones de Android o algún tipo de estructura de API que utilice servicios en la nube.

Hay varias formas de construir estos envoltorios para nuestros modelos, pero en este artículo, me centraré en cómo puede usar Streamlit como solución para este problema y por qué lo considero una herramienta tan poderosa.

Este artículo tendrá una guía paso a paso para crear un proyecto de ML y crear una plataforma de aplicación web para él usando Streamlit. El proyecto que construiremos es un modelo de predicción del precio de la vivienda en California. El sitio será dinámico y los hiperparámetros como la tasa de aprendizaje, la cantidad de neuronas, etc. se pueden cambiar y experimentar directamente a través de la aplicación web.

Si continúa con la creación de una aplicación web de este tipo utilizando algunos marcos como Flask o Django, estoy casi seguro de que llevará mucho tiempo crear primero esa interfaz de usuario, y luego hay otro problema de alojarla en un servidor para que puede ser accesible para todos.

Y aquí surge la pregunta principal: '¿Por qué los entusiastas del aprendizaje automático deberían perder el tiempo aprendiendo algunos marcos de interfaz de usuario cuando, en cambio, pueden usar ese valioso tiempo para aprender a construir mejores modelos?'

Aquí se tratarán muchos temas sobre cómo usar Streamlit para sus proyectos. Siéntase libre de saltar a cualquier parte sobre la que desee saber más.

• ¿Por qué Streamlit?
• Creación de un modelo básico de ML
• Agregar el Streamlit que usa magia
• Implementación de la aplicación web Streamlit
• Conclusión

¿Por qué Streamlit?

Streamlit hace que sea muy fácil y rápido para nosotros crear una aplicación web de Machine Learning. Otras formas disponibles para desarrollar tales contenedores para modelos ML no son muy cómodas.

Flask es un marco de Python que permite a los usuarios desarrollar aplicaciones web e implementarlas utilizando el lenguaje Python. Requiere un buen conocimiento de python y también necesitamos invertir tiempo en aprenderlo. Incluso después de eso, no es muy fácil desarrollar una aplicación web en comparación con Streamlit.

Django es otro marco basado en Python para el desarrollo web. Se puede decir que es una versión mejor y más compleja de Flask. Se requiere mucho tiempo dedicado para aprender este marco y, finalmente, crear una aplicación web que lo use no es tan rápido como nos gustaría que fuera.

Tensorflow.js es una excelente manera de guardar modelos que son compatibles con plataformas web y luego estos modelos se pueden usar para crear aplicaciones web. Muchas de las implementaciones complejas de modelos ML y arquitecturas de alto nivel aún no son compatibles con Tensorflow.js. Hay muchos modelos que funcionarán en Python y es posible que no funcionen en Javascript en la biblioteca Tensorflow.js.

Como dije antes, no deberíamos perder el tiempo aprendiendo estos marcos y, en cambio, aprender a construir buenos modelos de ML. Y aquí es donde Streamlit entra en escena. Es la forma más sencilla y rápida de desarrollar aplicaciones web. Las aplicaciones web creadas con Streamlit tienen excelentes elementos de interfaz de usuario y son muy fáciles de usar.

Para respaldar mi afirmación de que Streamlit es la forma más fácil y rápida de crear aplicaciones web ML, permítanme compartir con ustedes cómo encontré este marco. Estaba aprendiendo cómo construir GAN y usarlo para generar caras artificiales, convertir bocetos en blanco y negro en coloridos y otras implementaciones.

Los modelos funcionaron bien en el cuaderno Jupyter, pero quería compartirlo con otros. Empecé a buscar marcos para crear una aplicación y alojar el modelo, pero no quería perder el tiempo aprendiendo otro marco, ya que quería explorar otras implementaciones de GAN.

Revisé todos los recursos alternativos de los que hablé en este artículo anteriormente. El modelo generador utilizado en el proyecto de generación Sketch-To-Color es un poco complejo. Es un modelo de arquitectura U-Net y requiere que omita las conexiones.

Debido a su alta complejidad, no pude convertir el modelo final para Javascript usando Tensorflow.js. Aprender Flask o Django desde cero no era una opción para mí, así que comencé a buscar otros marcos o bibliotecas.

Fue entonces cuando me encontré con Streamlit. En un artículo de Adrien Treuille, muestra cómo creó una aplicación web increíble para un TL-GAN en menos de 13 líneas de código. Todo esto fue posible gracias a Streamlit.

La documentación en su sitio web oficial también es muy precisa y útil. Intenté crear una aplicación web Streamlit para mi modelo Sketch to Color GAN y fue increíble. Solo tuve que agregar 12 líneas de código a mi código python existente. Es por eso que finalmente seguí adelante con la exploración de Streamlit y la construcción de otros proyectos usándolo.

Creación de un modelo básico de ML

Como se indicó anteriormente, vamos a ver el problema de predicción del precio de la vivienda en California para este ejemplo. En primer lugar, veamos cómo construimos normalmente un modelo para esto. Es un problema de regresión.

Primero, importaremos las bibliotecas requeridas para nuestro modelo ML simple. Aquí usaremos TensorFlow, pandas y NumPy.

importar tensorflow como tf

importar numpy como np

importar pandas como pd

Ahora, usaremos los conjuntos de datos de Scikit-Learn para descargar el conjunto de datos de vivienda de California.

de sklearn.datasets import fetch_california_housing

vivienda = fetch_california_housing()

A continuación, necesitamos dividir los datos cargados en conjuntos de entrenamiento, validación y prueba. Hay muchos métodos disponibles para hacer esto. Usaremos la función train_test_split disponible en la biblioteca Scikit-Learn. Usarlo dos veces dividirá el conjunto de datos en 3 conjuntos de entrenamiento, validación y prueba.

de sklearn.model_selection import train_test_split

X_tren_completo, X_prueba, y_tren_completo, y_prueba = tren_prueba_dividida(

vivienda.datos, vivienda.objetivo

)

X_tren, X_válido, y_tren, y_válido = tren_prueba_dividir(

X_tren_completo, y_tren_completo

)

Los datos que tenemos a nuestra disposición tienen valores de longitud y latitud de cada entrada. Para visualizar esto mejor, podemos hacer un diagrama de dispersión en un mapa. Para usar los mapas, importaremos la biblioteca de Altair .

Importar altair como alt

map_data = pd.DataFrame(

tren_x,

columnas=[

'MedInc',

'Edad de la casa',

'AveRooms',

'AveBedrms',

'Población',

'AveOccup',

'latitud',

'longitud'

])

punto medio = (np.promedio(mapa_datos[“latitud”]), np.promedio(mapa_datos[“longitud”]))

st.write(pdk.Deck(

map_style=”mapbox://styles/mapbox/light-v9″,

estado_vista_inicial={

“latitud”: punto medio[0],

“longitud”: punto medio[1],

"acercar": 6,

"tono": 75,

},

capas=[

pdk.Layer(

“CapaHexágono”,

datos=mapa_datos,

get_position=[“longitud”, “latitud”],

radio=1000,

escala_elevación=4,

rango_elevación=[0, 10000],

seleccionable = Verdadero,

extruido = Verdadero,

),

],

))

Los datos que tenemos con nosotros ahora no se procesan bien para el modelo. Necesitamos hacer el preprocesamiento para obtener mejores resultados. En primer lugar, necesitaremos normalizar los valores, ya que la mayoría de los modelos de aprendizaje automático funcionan mejor cuando los datos se encuentran en un rango pequeño de valores. Para ello, utilizaremos la clase StandardScaler de la biblioteca sklearn.

de sklearn.preprocessing importar StandardScaler

escalador = StandardScaler()

Tren_X = escalador.fit_transform(tren_X)

X_valid = scaler.transform(X_valid)

X_test = escalador.transformar(X_test)

Después de preparar los datos, ahora crearemos un modelo. Este modelo será una red neuronal con un número específico de neuronas en la primera capa de entrada y una sola neurona en la última capa, ya que es un problema de regresión. Esto se puede lograr mediante el uso de la biblioteca TensorFlow.

importar tensorflow como tf

modelo = tf.keras.models.Sequential([

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

tf.keras.layers.denso(1)

])

En TensorFlow, tenemos que compilar el modelo después de construirlo. Aquí tenemos que mencionar la función de pérdida que usaremos y también el optimizador que queremos. Usaremos la función de pérdida de error cuadrático medio y el optimizador SGD con una tasa de aprendizaje específica.

modelo.compilar(

loss='mean_squared_error',

optimizador=tf.keras.optimizers.SGD(tasa_l)

)

Todo está en su lugar ahora. Todo lo que tenemos que hacer es entrenar el modelo. En TensorFlow, esto se puede hacer simplemente llamando al método fit(). Podemos guardar todos los registros en una variable, historial .

historia = modelo.fit(

tren_x,

y_tren,

épocas=n_épocas,

validación_datos=(X_válido, y_válido)

)

Después del entrenamiento, también podemos evaluar la precisión y la pérdida de nuestro modelo usando el método de evaluación().

evaluación = modelo.evaluar(X_test, y_test)

Ahora, si queremos predecir los precios de las casas usando este modelo, podemos hacerlo llamando al método predict() .

X_nuevo = X_prueba[:3]

predicciones = modelo.predecir(X_nuevo)

Así es como puede crear un modelo simple de predicción del precio de la vivienda con TensorFlow, scikit-learn y pandas. Pero el problema, como puede ver, es que no hay forma de mostrar este modelo a otros usuarios donde puedan interactuar con él y este es solo un modelo dentro de un Jupyter Notebook. ¡Así que ahora agreguemos un poco de magia con Streamlit!

Lea también: Ideas de proyectos de aprendizaje automático

Agregando la magia usando Streamlit

Para crear una aplicación web de Machine Learning, solo necesita agregar algunas líneas de código para las llamadas a funciones de Streamlit y eso es todo. No necesita HTML, CSS o Javascript. ¡Solo pitón puro!

Si, lo lees correctamente. No tienes que preocuparte por nada más. Simplemente instale Streamlit en su sistema y estará listo para comenzar. Utilice el siguiente comando en sus terminales:

pip instalar streamlit

Puede usar el siguiente comando para explorar en su aplicación hello world. Es un buen ejemplo de cómo se ven las aplicaciones web usando Streamlit.:

hola iluminada

Después de haber instalado Streamlit localmente y agregar la línea mágica al código, solo necesita ejecutar el siguiente comando para ejecutar la aplicación localmente:

streamlit ejecutar file_name.py

Entonces, la pregunta ahora es: "¿Qué son esas líneas mágicas de código?" Son bastante simples. Primero explicaré las funciones básicas que se usan en Streamlit y luego mostraré el código para que puedas relacionarlo directamente con el ejemplo.

Antes que nada, importaremos la biblioteca streamlit usando la siguiente línea de código:

importar streamlit como st

La primera característica importante es que simplemente puede escribir cualquier cosa en las 3 comillas dobles, simplemente muestra el texto tal como está en la aplicación web. Es compatible con la sintaxis del lenguaje Markdown. Entonces puede hacer muchas cosas como encabezados, viñetas, tablas y mucho más. También puede usar la función st.write() en lugar de esta notación. Tiene la misma funcionalidad.

La siguiente es la función with st.echo() :. Básicamente, esto ejecuta el código Python escrito en él y luego también lo muestra en la aplicación web. De esta manera podemos construir una aplicación web que muestre cómo fue construida.

st.empty() es un área que está reservada para algún contenido dinámico más adelante.

st.spinner() muestra un elemento de carga cuando hay algún retraso en la ejecución de un fragmento de código.

st.success() muestra un mensaje en color verde. Esto tiene un gran aspecto de diseño de diálogos de éxito.

st.sidebar() muestra el contenido en una barra lateral a la izquierda de forma predeterminada.

st.sidebar.slider() proporciona un control deslizante en la barra lateral para elegir valores de un rango de números dados. st.sidebar.selectbox() le permite seleccionar un valor de la lista dada y Streamlit tiene muchas más funciones y características maravillosas incluidas. Algunas de las características son las siguientes:

• Cambios en vivo cuando guarda el archivo
• Vuelva a ejecutar la aplicación simplemente presionando R en el teclado
• Un caché limpio simplemente presionando C en el teclado
• Grabe la aplicación web y guarde un archivo de video localmente para compartir con todos

…Y mucho más

Debe leer: Carrera en aprendizaje automático

El código

importar streamlit como st

importar altair como alt

importar pydeck como pdk

tren_área = st.vacío()

“””

# Precios de vivienda en California

Este es el conjunto de datos de precios de vivienda de California que contiene datos extraídos del censo de EE. UU. de 1990. La siguiente tabla proporciona descripciones, rangos de datos y tipos de datos para cada función en el conjunto de datos.

## Primero echemos un vistazo a las importaciones

“””

con st.echo():

importar tensorflow como tf

importar numpy como np

importar pandas como pd

“””

## Cargando el conjunto de datos

Usaremos el módulo de conjunto de datos de scikit-learn para generar datos que ya están limpios para nosotros y solo tienen las características numéricas.

“””

con st.echo():

de sklearn.datasets import fetch_california_housing

vivienda = fetch_california_housing()

“””

Esto cargará todos los datos en la variable `vivienda` como puede ver a continuación

“””

st.subheader('Características de entrada')

vivienda.datos

st.subheader('Etiquetas de salida')

vivienda.objetivo

“””

## Dividir los datos en conjuntos de entrenamiento, prueba y desarrollo

Esta es una de las cosas más importantes al comienzo de cualquier solución de aprendizaje automático, ya que el resultado de cualquier modelo puede depender en gran medida de qué tan bien haya distribuido los datos en estos conjuntos.

Afortunadamente para nosotros, tenemos scikit-learn al rescate donde se ha vuelto tan fácil como 2 líneas de código.

“””

con st.echo():

de sklearn.model_selection import train_test_split

X_tren_completo, X_prueba, y_tren_completo, y_prueba = tren_prueba_dividida(

vivienda.datos, vivienda.objetivo

)

X_tren, X_válido, y_tren, y_válido = tren_prueba_dividir(

X_tren_completo, y_tren_completo

)

“””

La función `train_test_split()` divide los datos en 2 conjuntos donde el conjunto de prueba es el 25% del conjunto de datos total. Hemos usado la misma función nuevamente en train_full para dividirlo en conjuntos de entrenamiento y validación. 25% es un parámetro predeterminado y puede modificarlo según sus necesidades. Mírelo desde [Documentación de Scikit-Learn] (https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html).

## Echando un vistazo a los datos del tren

Las columnas representan los siguientes datos:

“””

st.write(vivienda.feature_names)

“””

Ahora veamos la ubicación de las casas trazándola en el mapa usando los valores de Latitud y Longitud:

“””

con st.echo():

map_data = pd.DataFrame(

tren_x,

columnas=[

'MedInc',

'Edad de la casa',

'AveRooms',

'AveBedrms',

'Población',

'AveOccup',

'latitud',

'longitud'

])

punto medio = (np.promedio(mapa_datos[“latitud”]), np.promedio(mapa_datos[“longitud”]))

st.write(pdk.Deck(

map_style=”mapbox://styles/mapbox/light-v9″,

estado_vista_inicial={

“latitud”: punto medio[0],

“longitud”: punto medio[1],

"acercar": 6,

"tono": 75,

},

capas=[

pdk.Layer(

“CapaHexágono”,

datos=mapa_datos,

get_position=[“longitud”, “latitud”],

radio=1000,

escala_elevación=4,

rango_elevación=[0, 10000],

seleccionable = Verdadero,

extruido = Verdadero,

),

],

))

“””

**Siéntete libre de acercar o arrastrar mientras presionas la tecla ALT para cambiar el ángulo de visualización 3D del mapa, según sea necesario.**

## Preprocesamiento

Como se señaló anteriormente, este conjunto de datos ya está bien preprocesado por scikit-learn para que lo usemos directamente sin preocuparnos por los valores de NaN y otras cosas.

Sin embargo, vamos a escalar los valores en rangos específicos usando `StandardScaler` para ayudar a que nuestro modelo funcione de manera eficiente.

“””

con st.echo():

de sklearn.preprocessing importar StandardScaler

escalador = StandardScaler()

Tren_X = escalador.fit_transform(tren_X)

X_valid = scaler.transform(X_valid)

X_test = escalador.transformar(X_test)

“””

## Creando un modelo

Crearemos un modelo secuencial simple con la primera capa que contiene 30 neuronas y la función de activación de RELU.

La siguiente capa será una capa de una sola neurona sin función de activación, ya que queremos que el modelo prediga un rango de valores y no solo resultados binarios o multiclase como problemas de clasificación.

“””

st.sidebar.title('Hiperparámetros')

n_neuronas = st.sidebar.slider('Neuronas', 1, 128, 30)

l_rate = st.sidebar.selectbox('Tasa de aprendizaje', (0.0001, 0.001, 0.01), 1)

n_epochs = st.sidebar.number_input('Número de épocas', 1, 50, 20)

#Las n_neurons, l_rate y _nepochs son las entradas tomadas del usuario para entrenar el modelo. También se establecen los valores predeterminados para ellos. El valor predeterminado para n_neurons es 30, el valor predeterminado para l_rate es 0.01 y el valor predeterminado para n_epochs es 20. Entonces, al principio, el modelo tendrá 30 neuronas en la primera capa, la tasa de aprendizaje será 0.01 y el número de épocas para para el cual el modelo entrenará es 20.

con st.echo():

importar tensorflow como tf

modelo = tf.keras.models.Sequential([

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

tf.keras.layers.denso(1)

])

“””

## Compilando el modelo

La API de keras de Tensorflow nos proporciona la función `model.compile()` para asignar los optimizadores, la función de pérdida y algunos otros detalles para el modelo.

“””

con st.echo():

modelo.compilar(

loss='mean_squared_error',

optimizador=tf.keras.optimizers.SGD(tasa_l)

)

“””

## Entrenando al modelo

Para entrenar el modelo, simplemente tiene que llamar a la función `fit()` en el modelo con el conjunto de entrenamiento y validación y una cantidad de épocas para las que desea que se entrene el modelo.

**Intente jugar con los hiperparámetros de la barra lateral en el lado izquierdo y haga clic en el botón 'Modelo de entrenamiento' que se muestra a continuación para comenzar el entrenamiento.**

“””

tren = st.button('Modelo de tren')

si tren:

con st.spinner('Modelo de Entrenamiento…'):

con st.echo():

modelo.resumen(print_fn=lambda x: st.write(“{}”.format(x)))

historia = modelo.fit(

tren_x,

y_tren,

épocas=n_épocas,

validación_datos=(X_válido, y_válido)

)

st.success('¡Entrenamiento del modelo completo!')

“””

## Rendimiento del modelo

“””

con st.echo():

st.line_chart(pd.DataFrame(historia.historia))

“””

## Evaluación del modelo en el conjunto de prueba

Nuevamente, otro paso importante pero fácil de hacer es evaluar su modelo en los datos de prueba que nunca antes había visto. Recuerde que solo debe hacer esto después de estar lo suficientemente seguro sobre el modelo que ha construido y debe resistirse a realizar cualquier ajuste de hiperparámetros después de evaluar el modelo en el conjunto de prueba, ya que solo lo mejoraría para el conjunto de prueba y nuevamente habrá habrá un problema de generalización cuando el modelo verá nuevos datos en la fase de producción.

“””

con st.echo():

evaluación = modelo.evaluar(X_test, y_test)

evaluación

“””

> Esta pérdida en el conjunto de prueba es un poco peor que la del conjunto de validación, que es lo esperado, ya que el modelo nunca ha visto las imágenes del conjunto de prueba.

“””

“””

## Predicciones utilizando el Modelo

“””

con st.echo():

X_nuevo = X_prueba[:3]

predicciones = modelo.predecir(X_nuevo)

“””

### Predicciones

“””

predicciones

“””

### Verdad básica

“””

y_prueba[:3]

¡Esto fue! Solo unas pocas líneas de código adicional y ya ha creado una excelente aplicación web que se ve hermosa y también tiene contenido dinámico. No fue tan difícil, ¿verdad? Intente construir diferentes proyectos y usar otras funciones de Streamlit de su documentación. Es bastante fácil e intuitivo.

Leer: Aprendizaje automático con Python

Implementación de la aplicación web Streamlit

Las aplicaciones web Streamlit se pueden implementar para uso directo a través de varias opciones disponibles en Internet. Podemos repasarlos brevemente y ver cómo se puede hacer.

Antes de pasar a cualquier otra plataforma que pueda ayudarnos a implementar nuestras aplicaciones web, veamos qué tiene para ofrecernos Streamlit. Un lanzamiento de funciones muy reciente que han hecho es Streamlit Sharing. Esto permite a los usuarios implementar sus aplicaciones web Streamlit con un solo clic.

Si tiene su código cargado en sus repositorios de GitHub, simplemente puede elegir el repositorio desde el panel de control de Streamlit y automáticamente lo alojará por usted. Es muy sorprendente y totalmente gratis a partir de ahora. No ha habido una manera más fácil antes de implementar aplicaciones web de aprendizaje automático.

Heroku es otro buen método para implementar la aplicación web Streamlit. De esta forma, no tendrá que elegir ningún servidor en la nube y luego configurar instancias virtuales en ellos. Todo está a cargo de Heroku.

Hay un inconveniente simple en Heroku que su versión gratuita no le permitirá tener todos los paquetes de más del tamaño de 512 MB en una versión gratuita. TensorFlow 2.2.0 que usé para el proyecto es un poco más grande que el espacio especificado, así que tuve que usar otros servicios.

AWS (Amazon Web Services) también es una buena manera de implementar sus aplicaciones Streamlit. Es un poco complejo para un principiante, pero a medida que lo usa, se vuelve más fácil de configurar. Proporcionan instancias EC2 gratuitas para nuevos usuarios. Puede iniciar uno con Ubuntu 18.04 o superior e instalar todas las dependencias que se requieren para la aplicación.

Una vez que todo esté configurado, puede ejecutar la aplicación usando el comando: streamlit run filename.py. Aquí, obtendrá una URL pública que se puede compartir con todos. Un inconveniente importante aquí es que la aplicación no está disponible en línea si cierra la instancia. Entonces, una instancia gratuita tendrá algunas limitaciones.

Si tiene el código en el repositorio de GitHub, hay otra forma interesante de alojar su aplicación. No es muy profesional y legítimo porque el usuario también necesita tener Streamlit instalado en sus sistemas.

Si Streamlit está disponible en el sistema y tiene el enlace para el archivo python de la aplicación Streamlit, entonces puede ejecutar la aplicación web simplemente ejecutando el comando: streamlit run url . Puede consultar mi aplicación localmente si ha instalado Streamlit. Utilice el siguiente comando en sus terminales:

ejecutar streamlit https://raw.githubusercontent.com/tejasmorkar/housing_price_prediction_aws/master/CaliforniaHousingPrices.py

Conclusión

Has visto lo simple pero poderoso que es Streamlit. Nunca antes me había encontrado con una herramienta de este tipo que me haya ayudado tanto y haya facilitado mi vida de desarrollo. Entonces, es por eso que siento que Streamlit es un marco impresionante que puede ayudar a todos a enfocarse en las partes importantes del desarrollo de Machine Learning y ayudarnos a concentrarnos más en los principales aprendizajes de AI y ML. Esto hace que la curva de aprendizaje sea mucho más fácil y nos permite construir e implementar proyectos de pasatiempos fácilmente.

Una cosa que hace que este marco sea tan simple de implementar es su documentación oficial. Todo lo escrito en los documentos es preciso y sencillo. Le sugiero que revise los documentos una vez e intente implementar un nuevo proyecto. Es la mejor manera de comenzar con cualquier marco nuevo. Encuentre la documentación oficial de Streamlit en el siguiente enlace: https://docs.streamlit.io/en/stable/ target=”_blank” rel=”nofollow” .

La comunidad es siempre el mejor recurso para aprender cosas y encontrar un problema con nuestras soluciones. Streamlit tiene un maravilloso foro de discusión donde puede publicar cualquier pregunta sobre el proceso de desarrollo de una aplicación Streamlit, cualquier duda sobre la implementación, solicitudes de funciones, informes de errores y cualquier otra cosa que pueda ayudarlo a construir su aplicación con éxito. Únase al foro de discusión en el siguiente enlace: https://discuss.streamlit.io/

Si está interesado en obtener más información sobre el aprendizaje automático, consulte el Diploma PG en aprendizaje automático e IA de IIIT-B y upGrad, que está diseñado para profesionales que trabajan y ofrece más de 450 horas de capacitación rigurosa, más de 30 estudios de casos y asignaciones, IIIT- B Estado de exalumno, más de 5 proyectos prácticos finales prácticos y asistencia laboral con las mejores empresas.

¿Cuál es la mayor dificultad para implementar un proyecto de aprendizaje automático?

La mayor dificultad para implementar un proyecto de Machine Learning es que la recopilación de datos es incompleta. La mayoría de las veces, el tiempo y el dinero no son suficientes para recopilar todos los datos necesarios para tener un análisis preciso. Por lo tanto, los datos recopilados deben ser confiables y de buena calidad. Además, se deben elegir los datos correctos. La elección de los datos es clave para el despliegue de un proyecto.

¿Qué es Streamlit en el aprendizaje automático?

Streamlit es un algoritmo incremental para el aprendizaje automático. Aprovecha el hecho de que el espacio de búsqueda de las redes neuronales es muy grande y que el entrenamiento es rápido, por lo que no necesita buscar en todo el espacio, sino que puede construir una red neuronal localmente. StreamLit es una forma de memoria a largo plazo utilizada para procesar datos secuenciales. Es un algoritmo de aprendizaje profundo que utilizó RNN para codificar datos en vectores de números. Estos vectores se pueden utilizar para representar datos en gráficos o texto. También se puede utilizar para generar texto en lenguaje natural.

¿Cómo implemento usando Streamlit?

La implementación con Streamlit es simple. Primero, debe tener una cuenta Streamlit. En segundo lugar, necesita un software que pueda implementarse. Por ejemplo, Beanstalk, S3 o rsync. En tercer lugar, debe preparar su software para la implementación. Copie su aplicación a su servidor web usando rsync. Si está implementando un nuevo sitio web, entonces el sitio web es el directorio que copió. Si está implementando un sitio web existente, entonces el sitio web cargado es el directorio que copió. En el lado izquierdo de la pantalla debajo del