Um guia passo a passo para implantar modelos de ML usando o Streamlit

Introdução

A maioria dos entusiastas do Machine Learning está se matriculando em alguns cursos e currículos para começar a usar IA e ML. Esses cursos cobrem muitas coisas fundamentais e orientam os alunos para construir e treinar os modelos de ML de última geração.

Mas uma coisa com a qual a maioria dos iniciantes luta é a parte de implantação. Um projeto de aprendizado de máquina não pode ser deixado como está sem nenhum aplicativo interativo em torno dele. Para permitir que os usuários interajam facilmente com o modelo ou até mesmo mostrem nossos projetos, precisamos envolvê-los em aplicativos da Web, aplicativos Android ou algum tipo de estrutura de API usando serviços em nuvem.

Existem várias maneiras de construir esses wrappers para nossos modelos, mas neste artigo, vou me concentrar em como você pode usar o Streamlit como a solução para esse problema e por que o considero uma ferramenta tão poderosa.

Este artigo terá um guia passo a passo para criar um projeto de ML e criar uma plataforma de aplicativo da Web para ele usando o Streamlit. O projeto que estaremos construindo é um modelo de previsão de preços de casas da Califórnia. O site será dinâmico e hiperparâmetros como a taxa de aprendizado, número de neurônios, etc. podem ser alterados e experimentados diretamente pelo aplicativo da web.

Se você seguir em frente com a construção de um aplicativo da web usando alguns frameworks como Flask ou Django, tenho quase certeza de que levará muito tempo para construir primeiro essa interface do usuário e, em seguida, há outro problema de hospedá-lo em um servidor para que pode ser acessível a todos.

E aqui surge a questão principal: 'Por que os entusiastas de Machine Learning devem perder seu tempo aprendendo algumas estruturas de interface do usuário quando podem usar esse tempo valioso para aprender a construir modelos melhores?'

Haverá muitos tópicos abordados aqui sobre como usar o Streamlit para seus projetos. Sinta-se à vontade para pular para as partes sobre as quais deseja saber mais.

• Por que Streamlit?
• Como criar um modelo básico de ML
• Adicionando o Streamlit que usa magia
• Como implantar o aplicativo Web Streamlit
• Conclusão

Por que Streamlit?

O Streamlit torna muito fácil e rápido para nós criarmos um aplicativo da Web de Machine Learning. Outras formas disponíveis para desenvolver tais wrappers para modelos de ML não são muito confortáveis.

Flask é uma estrutura python que permite aos usuários desenvolver aplicativos da Web e implantá-los usando a linguagem python. Requer um bom conhecimento de python e também precisamos investir tempo em aprendê-lo. Mesmo depois disso, não é muito fácil desenvolver um aplicativo web quando comparado ao Streamlit.

Django é outro framework baseado em Python para desenvolvimento web. Pode-se dizer que é uma versão melhor e complexa do Flask. Requer muito tempo dedicado para aprender essa estrutura e, finalmente, criar um aplicativo da Web usando-o não é tão rápido quanto gostaríamos que fosse.

O Tensorflow.js é uma ótima maneira de salvar modelos compatíveis com plataformas da Web e, em seguida, esses modelos podem ser usados ​​para criar aplicativos da Web. Muitas das implementações complexas de modelos de ML e arquiteturas de alto nível ainda não são compatíveis com o Tensorflow.js. Existem muitos modelos que funcionam em Python e podem não funcionar em Javascript na biblioteca Tensorflow.js.

Como eu disse anteriormente, não devemos perder nosso tempo aprendendo essas estruturas e, em vez disso, aprender a construir bons modelos de ML. E é aqui que o Streamlit entra em cena. É a maneira mais simples e rápida de desenvolver aplicações web. Os aplicativos da Web criados usando o Streamlit têm ótimos elementos de interface do usuário e são muito fáceis de usar.

Para apoiar minha afirmação de que o Streamlit é a maneira mais fácil e rápida de criar aplicativos da Web de ML, deixe-me compartilhar com você como me deparei com essa estrutura. Eu estava aprendendo a construir GANs e usá-los para gerar rostos artificiais, converter esboços em preto e branco em coloridos e tais implementações.

Os modelos funcionaram bem no notebook Jupyter, mas eu queria compartilhá-lo com outras pessoas. Comecei a procurar frameworks para construir um aplicativo e hospedar o modelo, mas não queria perder meu tempo aprendendo mais um framework, pois queria explorar outras implementações de GAN.

Verifiquei todos os recursos alternativos sobre os quais falei neste artigo anteriormente. O modelo de gerador usado no projeto de geração Sketch-To-Color é um pouco complexo. É um modelo de arquitetura U-Net e requer que você ignore as conexões.

Devido à sua alta complexidade, não consegui converter o modelo final para Javascript usando o Tensorflow.js. Aprender Flask ou Django do zero não era uma opção para mim, então comecei a procurar outros frameworks ou bibliotecas.

Foi quando me deparei com o Streamlit. Em um artigo de Adrien Treuille, ele mostra como construiu um aplicativo web incrível para um TL-GAN em menos de 13 linhas de código. Tudo isso só foi possível por causa do Streamlit.

A documentação em seu site oficial também é muito precisa e útil. Eu tentei fazer um aplicativo da web Streamlit para o meu modelo Sketch to Color GANs e foi incrível. Eu só tive que adicionar 12 linhas de código ao meu código python existente. É por isso que finalmente fui em frente explorando o Streamlit e construindo outros projetos usando-o.

Como criar um modelo básico de ML

Como afirmado anteriormente, vamos analisar o problema de previsão de preços de casas da Califórnia para este exemplo. Em primeiro lugar, vamos ver como normalmente construímos um modelo para isso. É um problema de regressão.

Primeiro, importaremos as bibliotecas necessárias para nosso modelo de ML simples. Aqui estaremos usando TensorFlow, pandas e NumPy.

importe tensorflow como tf

importar numpy como np

importar pandas como pd

Agora, usaremos os conjuntos de dados do Scikit-Learn para baixar o conjunto de dados de habitação da Califórnia.

de sklearn.datasets importar fetch_california_housing

habitação = fetch_california_housing()

Em seguida, precisamos dividir os dados carregados em conjuntos de treinamento, validação e teste. Existem muitos métodos disponíveis para fazer isso. Usaremos a função train_test_split disponível na biblioteca Scikit-Learn. Usá-lo duas vezes dividirá o conjunto de dados em 3 conjuntos de treinamento, validação e teste.

de sklearn.model_selection importar train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(

habitação.dados, habitação.destino

)

X_train, X_valid, y_train, y_valid = train_test_split(

X_train_full, y_train_full

)

Os dados disponíveis para nós têm valores de longitude e latitude de cada entrada. Para visualizar melhor, podemos fazer um gráfico de dispersão em um mapa. Para usar os mapas, importaremos a biblioteca Altair .

Importar altair como alt

map_data = pd.DataFrame(

X_train,

colunas=[

'Medic',

'HouseAge',

'AveRooms',

'AveBedrms',

'População',

'AveOcupe',

'latitude',

'longitude'

])

ponto médio = (np.average(map_data[“latitude”]), np.average(map_data[“longitude”]))

st.write(pdk.Deck(

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

inicial_view_state={

“latitude”: ponto médio[0],

“longitude”: ponto médio[1],

“zoom”: 6,

“arremesso”: 75,

},

camadas=[

pdk.Camada(

“Camada Hexagonal”,

data=map_data,

get_position=[“longitude”, “latitude”],

raio = 1000,

escala_elevação=4,

intervalo_elevação=[0, 10000],

selecionável=Verdadeiro,

extrudado=Verdadeiro,

),

],

))

Os dados que temos conosco agora não são bem processados ​​para o modelo. Precisamos fazer o pré-processamento para obter melhores resultados. Antes de tudo, precisaremos normalizar os valores, pois a maioria dos modelos de Machine Learning funciona melhor quando os dados estão em um pequeno intervalo de valores. Para isso, usaremos a classe StandardScaler da biblioteca sklearn.

de sklearn.preprocessing importação StandardScaler

escalar = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_valid = scaler.transform(X_valid)

X_test = scaler.transform(X_test)

Depois de preparar os dados, vamos agora criar um modelo. Este modelo será uma rede neural com um número especificado de neurônios na primeira camada de entrada e um único neurônio na última camada, pois é um problema de regressão. Isso pode ser feito usando a biblioteca TensorFlow.

importe tensorflow como tf

modelo = tf.keras.models.Sequential([

tf.keras.layers.Dense(n_neurons, ativação='relu', input_shape=X_train.shape[1:]),

tf.keras.layers.Dense(1)

])

No TensorFlow, temos que compilar o modelo depois de construí-lo. Aqui temos que mencionar a função de perda que usaremos e também o otimizador que queremos. Usaremos a função de perda de erro quadrático médio e o otimizador SGD com uma taxa de aprendizado específica.

model.compile(

perda='mean_squared_error',

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

)

Tudo está no lugar agora. Tudo o que temos a fazer é treinar o modelo. No TensorFlow, isso pode ser feito simplesmente chamando o método fit(). Podemos salvar todos os logs em uma variável, history .

história = model.fit(

X_train,

y_train,

épocas=n_épocas,

validation_data=(X_valid, y_valid)

)

Após o treinamento, também podemos avaliar a precisão e a perda do nosso modelo usando o método assessment().

avaliação = model.evaluate(X_test, y_test)

Agora, se quisermos prever qualquer preço de casa usando este modelo, podemos fazê-lo chamando o método, predict() .

X_novo = X_test[:3]

previsões = model.predict(X_new)

É assim que você pode criar um modelo simples de previsão de preços de casas usando TensorFlow, scikit-learn e pandas. Mas o problema como você pode ver é que não há como mostrar este modelo para outros usuários onde eles podem interagir com ele e este é apenas um modelo dentro de um Jupyter Notebook. Então agora vamos adicionar um pouco de mágica com o Streamlit!

Leia também: Ideias de projetos de aprendizado de máquina

Adicionando a magia usando Streamlit

Para criar um aplicativo da Web de Machine Learning, você só precisa adicionar algumas linhas de código para chamadas de função Streamlit e pronto. Você não precisa de HTML, CSS ou Javascript. Apenas puro python!

Sim, você leu corretamente. Você não precisa se preocupar com mais nada. Basta instalar o Streamlit em seu sistema e você estará pronto para começar. Use o seguinte comando em seus terminais:

pip instalar streamlit

Você pode usar o seguinte comando para explorar o aplicativo hello world. É um bom exemplo de como os aplicativos da web ficam usando o Streamlit.:

olá iluminado

Depois de instalar o Streamlit localmente e adicionar a linha mágica ao código, basta executar o seguinte comando para executar o aplicativo localmente:

streamlit executar nome_do_arquivo.py

Então a questão agora é: “Quais são essas linhas mágicas de código?” Eles são bem simples. Primeiro explicarei as funções básicas usadas no Streamlit e depois mostrarei o código para que você possa relacioná-lo diretamente com o exemplo.

Antes de mais nada, vamos importar a biblioteca streamlit usando a seguinte linha de código:

importação simplificada como st

O primeiro recurso importante é que você pode simplesmente digitar qualquer coisa entre as 3 aspas duplas, ele simplesmente mostra o texto como está no aplicativo da web. Ele suporta a sintaxe da linguagem markdown. Assim, você pode fazer muitas coisas, como cabeçalhos, marcadores, tabelas e muito mais. Você também pode usar a função st.write() em vez desta notação. Tem a mesma funcionalidade.

A seguir vem a função with st.echo():. Isso basicamente executa o código python escrito nele e também o mostra no aplicativo da web. Dessa forma, podemos construir um aplicativo web que mostra como ele foi construído.

st.empty() é uma área reservada para algum conteúdo dinâmico posteriormente.

st.spinner() mostra um elemento de carregamento quando há algum atraso na execução de um pedaço de código.

st.success() mostra uma mensagem na cor verde. Isso tem um ótimo aspecto de design de diálogos de sucesso.

st.sidebar() exibe o conteúdo em uma barra lateral à esquerda por padrão.

st.sidebar.slider() fornece um controle deslizante na barra lateral para escolher valores de um intervalo de números fornecidos. st.sidebar.selectbox() permite que você selecione um valor da lista fornecida e O Streamlit possui muitas outras funções e recursos maravilhosos. Algumas das características são as seguintes:

• Mudanças ao vivo quando você salva o arquivo
• Execute novamente o aplicativo simplesmente pressionando R no teclado
• Um cache limpo simplesmente pressionando C no teclado
• Grave o aplicativo da web e salve um arquivo de vídeo localmente para compartilhar com todos

…E muito mais

Leitura obrigatória: Carreira em Machine Learning

O código

importação simplificada como st

importar altair como alt

importar pydeck como pdk

train_area = st.empty()

“””

# Preços de imóveis na Califórnia

Este é o conjunto de dados de preços de habitação da Califórnia que contém dados extraídos do Censo dos EUA de 1990. A tabela a seguir fornece descrições, intervalos de dados e tipos de dados para cada recurso no conjunto de dados.

## Vamos primeiro dar uma olhada nas importações

“””

com st.eco():

importe tensorflow como tf

importar numpy como np

importar pandas como pd

“””

## Carregando o conjunto de dados

Usaremos o módulo de conjunto de dados do scikit-learn para conduzir os dados que já estão limpos para nós e possuem apenas os recursos numéricos.

“””

com st.eco():

de sklearn.datasets importar fetch_california_housing

habitação = fetch_california_housing()

“””

Isso carregará todos os dados na variável `housing` como você pode ver abaixo

“””

st.subheader('Recursos de entrada')

habitação.dados

st.subheader('Etiquetas de saída')

habitação.alvo

“””

## Dividindo os dados em conjuntos Train, Test e Dev

Essa é uma das coisas mais importantes no início de qualquer solução de Machine Learning, pois o resultado de qualquer modelo pode depender muito de quão bem você distribuiu os dados nesses conjuntos.

Felizmente para nós, temos scikit-learn para o resgate, onde se tornou tão fácil quanto 2 linhas de código.

“””

com st.eco():

de sklearn.model_selection importar train_test_split

X_train_full, X_test, y_train_full, y_test = train_test_split(

habitação.dados, habitação.destino

)

X_train, X_valid, y_train, y_valid = train_test_split(

X_train_full, y_train_full

)

“””

A função `train_test_split()` divide os dados em 2 conjuntos onde o conjunto de teste é 25% do conjunto de dados total. Usamos a mesma função novamente no train_full para dividi-lo em conjuntos de trem e validação. 25% é um parâmetro padrão e você pode ajustá-lo conforme suas necessidades. Dê uma olhada na [Documentação do Scikit-Learn](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html).

## Dando uma olhada nos dados do trem

As colunas representam os seguintes dados:

“””

st.write(housing.feature_names)

“””

Agora vamos ver a localização das casas plotando-a no mapa usando os valores de Latitude e Longitude:

“””

com st.eco():

map_data = pd.DataFrame(

X_train,

colunas=[

'Medic',

'HouseAge',

'AveRooms',

'AveBedrms',

'População',

'AveOcupe',

'latitude',

'longitude'

])

ponto médio = (np.average(map_data[“latitude”]), np.average(map_data[“longitude”]))

st.write(pdk.Deck(

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

inicial_view_state={

“latitude”: ponto médio[0],

“longitude”: ponto médio[1],

“zoom”: 6,

“arremesso”: 75,

},

camadas=[

pdk.Camada(

“Camada Hexagonal”,

data=map_data,

get_position=[“longitude”, “latitude”],

raio = 1000,

escala_elevação=4,

intervalo_elevação=[0, 10000],

selecionável=Verdadeiro,

extrudado=Verdadeiro,

),

],

))

“””

**Sinta-se à vontade para ampliar ou arrastar enquanto pressiona a tecla ALT para alterar o ângulo de visualização 3D do mapa, conforme necessário.**

## Pré-processando

Como apontado anteriormente, esse conjunto de dados já está bem pré-processado pelo scikit-learn para usarmos diretamente sem nos preocuparmos com valores NaN e outras coisas.

No entanto, vamos dimensionar os valores em intervalos específicos usando `StandardScaler` para ajudar nosso modelo a funcionar com eficiência.

“””

com st.eco():

de sklearn.preprocessing importação StandardScaler

escalar = StandardScaler()

X_train = scaler.fit_transform(X_train)

X_valid = scaler.transform(X_valid)

X_test = scaler.transform(X_test)

“””

## Criando um modelo

Estaremos criando um Modelo Sequencial simples com a primeira camada contendo 30 neurônios e a função de ativação do RELU.

A próxima camada será uma única camada de neurônio sem função de ativação, pois queremos que o modelo preveja um intervalo de valores e não apenas resultados binários ou multiclasse, como problemas de classificação.

“””

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

n_neurons = st.sidebar.slider('Neurônios', 1, 128, 30)

l_rate = st.sidebar.selectbox('Taxa de aprendizado', (0,0001, 0,001, 0,01), 1)

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

#Os n_neurons, l_rate e _nepochs são as entradas obtidas do usuário para treinar o modelo. Os valores padrão para eles também são definidos. O valor padrão para n_neurons é 30, o valor padrão para l_rate é 0,01 e o valor padrão para n_epochs é 20. Então no início o modelo terá 30 neurônios na primeira camada, a taxa de aprendizado será 0,01 e o número de épocas para para o qual o modelo irá treinar é 20.

com st.eco():

importe tensorflow como tf

modelo = tf.keras.models.Sequential([

tf.keras.layers.Dense(n_neurons, ativação='relu', input_shape=X_train.shape[1:]),

tf.keras.layers.Dense(1)

])

“””

## Compilando o modelo

A API do Tensorflow keras nos fornece a função `model.compile()` para atribuir os otimizadores, a função de perda e alguns outros detalhes para o modelo.

“””

com st.eco():

model.compile(

perda='mean_squared_error',

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

)

“””

## Treinando o modelo

Para treinar o modelo, basta chamar a função `fit()` no modelo com o conjunto de treinamento e validação e um número de épocas para as quais você deseja que o modelo seja treinado.

**Tente brincar com os hiperparâmetros da barra lateral do lado esquerdo e clique no botão "Train Model" abaixo para iniciar o treinamento.**

“””

trem = st.button('Modelo de Trem')

se treinar:

with st.spinner('Modelo de treinamento…'):

com st.eco():

model.summary(print_fn=lambda x: st.write(“{}”.format(x)))

história = model.fit(

X_train,

y_train,

épocas=n_épocas,

validation_data=(X_valid, y_valid)

)

st.success('Treinamento do modelo concluído!')

“””

## Desempenho do modelo

“””

com st.eco():

st.line_chart(pd.DataFrame(history.history))

“””

## Avaliando o modelo no conjunto de teste

Novamente, outro passo importante, mas fácil de fazer, é avaliar seu modelo nos dados de teste que ele nunca viu antes. Lembre-se de que você só deve fazer isso depois de ter certeza sobre o modelo que construiu e deve resistir a fazer qualquer ajuste de hiperparâmetro após avaliar o modelo no conjunto de teste, pois isso o tornaria melhor para o conjunto de teste e, novamente, haverá ser um problema de generalização quando o modelo verá novos dados na fase de produção.

“””

com st.eco():

avaliação = model.evaluate(X_test, y_test)

avaliação

“””

> Essa perda no conjunto de teste é um pouco pior do que no conjunto de validação, o que é esperado, pois o modelo nunca viu as imagens do conjunto de teste.

“””

“””

## Previsões usando o modelo

“””

com st.eco():

X_novo = X_test[:3]

previsões = model.predict(X_new)

“””

### Previsões

“””

previsões

“””

### Verdade do terreno

“””

y_test[:3]

Era isso! Apenas algumas linhas de código extra e você já construiu um ótimo aplicativo da web que parece bonito e também possui conteúdo dinâmico. Não foi tão difícil, foi? Tente construir projetos diferentes e usar outras funções do Streamlit de sua documentação. É bem fácil e intuitivo.

Leia: Aprendizado de máquina com Python

Como implantar o aplicativo da Web Streamlit

Os aplicativos da Web Streamlit podem ser implantados para uso direto por meio de várias opções disponíveis na Internet. Podemos analisá-los brevemente e ver como isso pode ser feito.

Antes de ir para qualquer outra plataforma que possa nos ajudar a implantar nossos aplicativos da web, vamos ver o que o Streamlit tem a nos oferecer. Um lançamento de recurso muito recente que eles fizeram é o Streamlit Sharing. Isso permite que os usuários implantem seus aplicativos da web Streamlit em um único clique.

Se você tiver seu código carregado em seus repositórios do GitHub, basta escolher o repositório no painel do Streamlit e ele o hospedará automaticamente para você. É muito incrível e totalmente gratuito a partir de agora. Não havia nenhuma maneira mais fácil antes de implantar aplicativos da Web de aprendizado de máquina.

Heroku é outro bom método para implantar o aplicativo da web Streamlit. Dessa forma, você não precisará escolher nenhum servidor em nuvem e configurar instâncias virtuais neles. Tudo é cuidado por Heroku.

Há uma desvantagem simples no Heroku que sua versão gratuita não permite que você tenha todos os pacotes com mais de 512 MB em uma versão gratuita. O TensorFlow 2.2.0 que usei para o projeto é um pouco maior que o espaço especificado, então tive que usar outros serviços.

AWS (Amazon Web Services) também é uma boa maneira de implantar seus aplicativos Streamlit. É um pouco complexo para um iniciante, mas à medida que você o usa, fica mais fácil de configurar. Eles fornecem instâncias EC2 gratuitas para novos usuários. Você pode iniciar um com o Ubuntu 18.04 ou superior e instalar todas as dependências necessárias para o aplicativo.

Depois que tudo estiver configurado, você pode executar o aplicativo usando o comando – streamlit run filename.py. Aqui, você obterá um URL público que pode ser compartilhado com todos. Uma grande desvantagem aqui é que o aplicativo não está disponível online se você desligar a instância. Portanto, uma instância gratuita terá algumas limitações.

Se você tiver o código no repositório do GitHub, há outra maneira legal de hospedar seu aplicativo. Não é muito profissional e legítimo porque o usuário também precisa ter o Streamlit instalado em seus sistemas.

Se o Streamlit estiver disponível no sistema e você tiver o link para o arquivo python do aplicativo Streamlit, poderá executar o aplicativo da Web simplesmente executando o comando: streamlit run url . Você pode conferir meu aplicativo localmente se tiver instalado o Streamlit. Use o seguinte comando em seus terminais:

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

Conclusão

Você viu como o Streamlit é simples e poderoso. Eu não encontrei tal ferramenta antes que me ajudasse a esse ponto e facilitou minha vida de desenvolvimento. Então, é por isso que sinto que o Streamlit é uma estrutura impressionante que pode ajudar todos a se concentrarem nas partes importantes do desenvolvimento de Machine Learning e nos ajudar a nos concentrar mais nos principais aprendizados de IA e ML. Isso torna a curva de aprendizado muito mais fácil e nos permite criar e implantar projetos de hobby com facilidade.

Uma coisa que torna este framework tão simples para implementação é sua documentação oficial. Tudo escrito nos documentos é preciso e simples. Eu sugiro que você revise os documentos uma vez e tente implementar um novo projeto. É a melhor maneira de começar com novos frameworks. Encontre a documentação oficial do Streamlit no link a seguir — https://docs.streamlit.io/en/stable/ target=”_blank” rel=”nofollow” .

A comunidade é sempre o melhor recurso para aprender coisas e encontrar um problema com nossas soluções. O Streamlit tem um fórum de discussão maravilhoso onde você pode postar qualquer dúvida sobre o processo de desenvolvimento de um aplicativo Streamlit, qualquer dúvida sobre implantação, solicitações de recursos, relatórios de bugs e qualquer outra coisa que possa ajudá-lo a construir seu aplicativo com sucesso. Participe do fórum de discussão no link a seguir — https://discuss.streamlit.io/

Se você estiver interessado em aprender mais sobre aprendizado de máquina, confira o PG Diploma in Machine Learning & AI do IIIT-B e upGrad, projetado para profissionais que trabalham e oferece mais de 450 horas de treinamento rigoroso, mais de 30 estudos de caso e atribuições, IIIT- B Status de ex-aluno, mais de 5 projetos práticos práticos e assistência de trabalho com as principais empresas.

Qual é a maior dificuldade na implantação de um projeto de machine learning?

A maior dificuldade na implantação de um projeto de Machine Learning é a incompletude da coleta de dados. Na maioria das vezes o tempo e o dinheiro não são suficientes para coletar todos os dados necessários para uma análise precisa. Portanto, os dados coletados devem ser confiáveis ​​e de boa qualidade. Além disso, os dados corretos devem ser escolhidos. A escolha dos dados é fundamental para a implantação de um projeto.

O que é Streamlit no aprendizado de máquina?

Streamlit é um algoritmo incremental para aprendizado de máquina. Ele explora o fato de que o espaço de busca das redes neurais é muito grande e que o treinamento é rápido, e assim não precisa buscar todo o espaço, mas pode construir uma rede neural localmente. StreamLit é uma forma de memória de curto prazo longa usada para processar dados sequenciais. É um algoritmo de aprendizado profundo que usou RNNs para codificar dados em vetores de números. Esses vetores podem ser usados ​​para representar dados em gráficos ou texto. Também pode ser usado para gerar texto em linguagem natural.

Como faço para implantar usando o Streamlit?

A implantação com o Streamlit é simples. Primeiro, você precisa ter uma conta Streamlit. Em segundo lugar, você precisa de um software que possa ser implantado. Por exemplo, Beanstalk, S3 ou rsync. Terceiro, você precisa preparar seu software para implantação. Copie seu aplicativo para seu servidor web usando rsync. Se você estiver implantando um novo site, o site será o diretório que você copiou. Se você estiver implantando um site existente, o site carregado será o diretório que você copiou. No lado esquerdo da tela sob o