streamlit é uma poderosa estrutura de fonte aberta que permite criar Web Applications para Data Science e aprendizado de máquina com apenas algumas linhas de código python.

é simples, intuitivo, e não requer experiência no front -end , tornando -a uma ótima ferramenta para iniciantes e desenvolvedores experientes que desejam implantar rapidamente modelos de aprendizado de máquina.

Neste blog, vou guiá-lo através de um processo passo a passo para criar um aplicativo básico de streamlit e um projeto de aprendizado de máquina usando o conjunto de dados iris com um randomforestclassifier.

começando com o streamlit

Antes de entrarmos no projeto, vamos percorrer alguma funcionalidade básica de streamlit para se sentir confortável com a estrutura. Você pode instalar o streamlit usando o seguinte comando:

pip install streamlit

Depois de instalado, você pode iniciar seu primeiro aplicativo STREAMLIT criando um arquivo python, digamos App.py e executando -o usando:

streamlit run app.py

agora, vamos explorar os principais recursos de streamlit:

1. Escrevendo títulos e exibindo texto

import streamlit as st

# Writing a title
st.title("Hello World")

# Display simple text
st.write("Displaying a simple text")

2. Exibindo DataFrames

import pandas as pd

# Creating a DataFrame
df = pd.DataFrame({
    "first column": [1, 2, 3, 4],
    "second column": [5, 6, 7, 8]
})

# Display the DataFrame
st.write("Displaying a DataFrame")
st.write(df)

3. Visualizando dados com gráficos

import numpy as np

# Generating random data
chart_data = pd.DataFrame(
    np.random.randn(20, 4), columns=['a', 'b', 'c', 'd']
)

# Display the line chart
st.line_chart(chart_data)

4. Interação do usuário: entrada de texto, controles deslizantes e selecione caixas
streamlit Ativa widgets interativos, como entradas de texto, controles deslizantes e selecione caixas que atualizam dinamicamente com base na entrada do usuário.

# Text input
name = st.text_input("Your Name Is:")
if name:
    st.write(f'Hello, {name}')

# Slider
age = st.slider("Select Your Age:", 0, 100, 25)
if age:
    st.write(f'Your Age Is: {age}')

# Select Box
choices = ["Python", "Java", "Javascript"]
lang = st.selectbox('Favorite Programming Language', choices)
if lang:
    st.write(f'Favorite Programming Language is {lang}')

5. FILE Upload
Você pode permitir que os usuários enviem arquivos e exibam seus conteúdos dinamicamente no seu aplicativo STREAMLIT :

# File uploader for CSV files
file = st.file_uploader('Choose a CSV file', 'csv')

if file:
    data = pd.read_csv(file)
    st.write(data)

Construindo um projeto de aprendizado de máquina com streamlit

! Usaremos o famoso conjunto de dados da IRIS e criaremos uma classificação simples

modelo usando RandomForestClassifier de scikit-learn . estrutura do projeto:

carregue o conjunto de dados.

Treine um RandomForestClassifier.
permite que os usuários inseram recursos usando sliders.
prevê as espécies com base nos recursos de entrada.
1. Instale as dependências necessárias

Primeiro, vamos instalar as bibliotecas necessárias: PIP Instale o streamlit scikit-learn numpy pandas

pip install streamlit scikit-learn numpy pandas

Vamos importar as bibliotecas necessárias e carregar o conjunto de dados da IRIS: importar streamlit como st importar pandas como PD de sklearn.datasets import load_iris de sklearn.ensemble importar Randomforestclassifier # Dados de cache para carregamento eficiente @St.Cache_Data def load_data (): íris = load_iris () df = pd.dataframe (iris.data, colunas = iris.feature_names) df ["espécies"] = iris.target Retorne df, iris.target_names df, Target_name = load_data ()

import streamlit as st
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.ensemble import RandomForestClassifier

# Cache data for efficient loading
@st.cache_data
def load_data():
    iris = load_iris()
    df = pd.DataFrame(iris.data, columns=iris.feature_names)
    df["species"] = iris.target
    return df, iris.target_names

df, target_name = load_data()

Depois de termos os dados, treinaremos um RandomForestClassifier para prever as espécies de uma flor com base em seus recursos: # Treine RandomforestClassifier Model = RandomForestClassifier () Model.fit (df.iloc [:, -1], df ["espécies"])

# Train RandomForestClassifier
model = RandomForestClassifier()
model.fit(df.iloc[:, :-1], df["species"])

Agora, criaremos controles deslizantes na barra lateral para permitir que os usuários inseram recursos para fazer previsões: # Barra lateral para entrada do usuário St.sidebar.title ("Recursos de entrada") Sepal_length = St.sidebar.slider ("Comprimento da Sépala", Float (df ['Comprimento da sépala (cm)']. Sepal_width = St.sidebar.slider ("Largura da Sépala", Float (df ['largura sépica (cm)']. petal_length = s.sidebar.slider ("comprimento da pétala", flutuação (df ['comprimento da pétala (cm)']. min ()), flutuação (df ['comprimento da pétala (cm)']. petal_width = St.sidebar.slider ("largura da pétala", flutuação (df ['largura da pétala (cm)'].

# Sidebar for user input
st.sidebar.title("Input Features")
sepal_length = st.sidebar.slider("Sepal length", float(df['sepal length (cm)'].min()), float(df['sepal length (cm)'].max()))
sepal_width = st.sidebar.slider("Sepal width", float(df['sepal width (cm)'].min()), float(df['sepal width (cm)'].max()))
petal_length = st.sidebar.slider("Petal length", float(df['petal length (cm)'].min()), float(df['petal length (cm)'].max()))
petal_width = st.sidebar.slider("Petal width", float(df['petal width (cm)'].min()), float(df['petal width (cm)'].max()))

Depois de obter as entradas do usuário, faremos uma previsão usando o modelo treinado: # Prepare os dados de entrada input_data = [[sepal_length, Sepal_width, petal_length, petal_width]] # Previsão Previsão = Model.Predict (input_data) Prediction_Species = Target_Name [Previsão [0]] # Exiba a previsão St.Write ("Previsão:") St.Write (espécies preticiadas é {Prediction_Species} ')

isso se parece:

# Prepare the input data
input_data = [[sepal_length, sepal_width, petal_length, petal_width]]

# Prediction
prediction = model.predict(input_data)
prediction_species = target_name[prediction[0]]

# Display the prediction
st.write("Prediction:")
st.write(f'Predicted species is {prediction_species}')

finalmente, STREAMLIT

torna incrivelmente fácil criar e implantar a interface da Web de aprendizado de máquina com um esforço mínimo. ? Em apenas algumas linhas de código, criamos um aplicativo interativo? Isso permite aos usuários inserir recursos e prever as espécies de uma flor? usando um modelo de aprendizado de máquina. ??

Codificação feliz! ?