Criamos um mecanismo de pesquisa semântica com aprendizado de máquina em tempo real para 300 linhas de código Python.Minha experiência sugere que qualquer projeto de aprendizado de máquina mais ou menos complexo se tornará, mais cedo ou mais tarde, um conjunto de ferramentas internas complexas e sem suporte. Essas ferramentas geralmente são uma mistura de scripts dos Jupyter Notebooks e Flask, que são difíceis de implantar e integrar com soluções como sessões da GPU Tensorflow.
Eu o encontrei pela primeira vez na Carnegie University, depois em Berkeley, no Google X e, finalmente, ao criar robôs independentes na Zoox. As ferramentas nasceram na forma de pequenos notebooks Jupyter: um utilitário de calibração de sensores, um serviço de simulação, um aplicativo LIDAR, um utilitário de script etc.
Com a crescente importância das ferramentas, os gerentes apareceram. A burocracia estava crescendo. Requisitos aumentados. Pequenos projetos se transformaram em enormes pesadelos constrangedores.
Ciclo: 1. Explore no Jupyter 2. Copie e cole no script Python 3. Escreva um aplicativo Flask com HTML, JS e mais 4. Adicione mais funcionalidades. // Os problemas de suporte começam logo na etapa 3Quando a ferramenta se tornou crítica, contratamos uma equipe para criar as ferramentas . Eles usaram Vue e React. Seus laptops estavam cobertos com adesivos de conferências-quadro declarativas. Eles tiveram seu próprio processo de depuração:
Um processo simplificado: 1. Coleta de requisitos 2. Modelo para componentes reativos 3. Criando um aplicativo em HTML, CSS, Python, React etc. 4. Um mês depois: "O aplicativo está pronto, podemos atualizá-lo em alguns meses". // Após o passo 4, o trabalho se move à velocidade da tartarugaO processo foi maravilhoso. Aqui estão apenas as ferramentas que aparecem todas as semanas. E a equipe de ferramentas apoiou mais dez outros projetos. A adição de novas funcionalidades levou meses.
Então, voltamos a criar nossas próprias ferramentas, implantando aplicativos Flask, escrevendo HTML, CSS e JavaScript e tentando portar tudo isso no Jupyter, preservando os estilos. Então, meu antigo amigo do Google X, Thiago Teheheira, e eu começamos a refletir sobre a pergunta: E se pudéssemos criar ferramentas tão facilmente quanto escrevemos scripts em Python?
Queríamos que os especialistas em aprendizado de máquina pudessem criar aplicativos elegantes sem envolver equipes para criar ferramentas. As ferramentas internas não devem ser um fim em si, mas um subproduto do trabalho com ML. Escrever um utilitário deve ser sentido como parte do trabalho de treinar uma rede neural ou conduzir análises no Jupyter! Mas, ao mesmo tempo, queríamos ter a flexibilidade e o poder de uma estrutura da web. Na verdade, queríamos algo assim:
O processo de trabalho no Streamlit: 1. Adicione algumas chamadas à API no seu script 2. Uma linda ferramenta está pronta!Com a ajuda de uma excelente comunidade de engenheiros do Uber, Twitter, Stitch Fix e Dropbox, desenvolvemos o Streamlit ao longo do ano - uma estrutura de código aberto gratuita para ajudar os trabalhadores de aprendizado de máquina. A cada iteração subsequente, os princípios no núcleo do Streamlit se tornavam mais simples. É para isso que chegamos:
# 1: Use o conhecimento de Python. Aplicativos streamlit são scripts executados de cima para baixo. Não há estado oculto neles. Se você pode escrever em Python, pode criar aplicativos no Streamlit. Veja como a tela é exibida:
import streamlit as st st.write('Hello, world!')
O primeiro conhecido.# 2: Pense nos widgets como variáveis. Não há retornos de chamada no Streamlit ! Cada alteração simplesmente reinicia o script de cima para baixo. Essa abordagem permite que você escreva um limpador de código:
import streamlit as st x = st.slider('x') st.write(x, 'squared is', x * x)
Um aplicativo interativo em três linhas de código.# 3: use dados e cálculos repetidamente. E se você baixasse muitos dados para realizar cálculos longos? Então será importante reutilizá-los entre as reinicializações. O Streamlit possui uma primitiva para cache persistente do estado inalterado padrão. Assim, por exemplo, o código abaixo baixa os dados do projeto Udacity em carros autogerenciados uma vez , produzindo um aplicativo simples e bonito:
import streamlit as st import pandas as pd # Reuse this data across runs! read_and_cache_csv = st.cache(pd.read_csv) BUCKET = "https://streamlit-self-driving.s3-us-west-2.amazonaws.com/" data = read_and_cache_csv(BUCKET + "labels.csv.gz", nrows=1000) desired_label = st.selectbox('Filter to:', ['car', 'truck']) st.write(data[data.label == desired_label])
Para executar o código acima, siga as instruções aqui .
E aqui está como o resultado será.Em resumo, o Streamlit funciona assim:
- O script é executado novamente sempre
- O Streamlit atribui a cada variável o valor atual dos widgets.
- O armazenamento em cache evita acesso desnecessário à rede ou recálculos longos.
O trabalho de Streamlit em imagens:
A entrada do usuário reinicia o script. Entre as reinicializações, apenas o cache é salvo.Você está intrigado? Então tente você mesmo! Execute:
$ pip install --upgrade streamlit $ streamlit hello . URL: http://localhost:8501 URL: http://10.0.1.29:8501
Este código abrirá o aplicativo Streamlit em um navegador. Se isso não acontecer, basta clicar no link.
Para ver mais exemplos como essa animação fractal, basta executar o hello streamlit na linha de comando.
Não jogou o suficiente com fractais? Tenha cuidado, os fractais podem ficar presos por muito tempo.
A simplicidade dos exemplos não deve ser enganosa: você pode criar aplicativos enormes no Streamlit. Trabalhando no Zoox e no Google X, vi como projetos automáticos de direção automática inflavam em gigabytes de dados visuais que precisavam ser encontrados e processados, incluindo testes de modelos diferentes para comparar o desempenho. Cada pequeno projeto em máquinas autônomas, mais cedo ou mais tarde, aumentou para o tamanho de exigir uma equipe de desenvolvimento separada.
Mas com o Streamlit, a criação de tais aplicativos é trivial. Aqui está uma demonstração no Streamlit , onde uma pesquisa semântica completa é implementada em toda a matriz de dados Udacity para máquinas autônomas , visualização de rótulos anotados por pessoas e o lançamento de uma rede neural completa ( YOLO ) em tempo real no mesmo aplicativo [1].
Esta demonstração de 300 linhas no Streamlit combina pesquisa semântica com resultados em tempo real de uma rede neural.A aplicação é completamente auto-suficiente, a maioria das 300 linhas é de aprendizado de máquina. Além disso, a API Streamlit é chamada apenas 23 vezes . Tente você mesmo!
$ pip install --upgrade streamlit opencv-python $ streamlit run https://raw.githubusercontent.com/streamlit/demo-self-driving/master/app.py
No processo de trabalho com equipes de aprendizado de máquina, percebemos que algumas idéias simples valem a pena:
Aplicativos Streamlit são arquivos Python regulares. Portanto, você pode usar seu editor favorito para desenvolver todo o aplicativo.
Meu fluxo de trabalho com o Streamlit inclui o VSCode à esquerda e o Chrome à direita.Scripts limpos são armazenados sem problemas no Git ou em outros sistemas de controle de versão. Trabalhando com python puro, você obtém um enorme conjunto de ferramentas prontas para o desenvolvimento em equipe.
O aplicativo Streamlit está totalmente hospedado no Git.Streamlit é um ambiente de codificação de resposta instantânea. Basta clicar em Sempre executar novamente quando o Streamlit perceber uma alteração no arquivo de origem.
Clique em “Sempre executar novamente” para codificação de resposta instantânea.O cache simplifica bastante o trabalho com a cadeia de computação. A combinação de vários resultados de armazenamento em cache funciona muito bem como um pipeline eficiente para a computação! Veja este código retirado da demonstração do Udacity :
import streamlit as st import pandas as pd @st.cache def load_metadata(): DATA_URL = "https://streamlit-self-driving.s3-us-west-2.amazonaws.com/labels.csv.gz" return pd.read_csv(DATA_URL, nrows=1000) @st.cache def create_summary(metadata, summary_type): one_hot_encoded = pd.get_dummies(metadata[["frame", "label"]], columns=["label"]) return getattr(one_hot_encoded.groupby(["frame"]), summary_type)() # Piping one st.cache function into another forms a computation DAG. summary_type = st.selectbox("Type of summary:", ["sum", "any"]) metadata = load_metadata() summary = create_summary(metadata, summary_type) st.write('## Metadata', metadata, '## Summary', summary)
Pipeline para computação Streamlit. Para executar o script, siga estas instruções .
De fato, o pipeline é load_metadata -> create_summary. Cada vez que o script é executado, o Streamlit narra apenas o necessário para o resultado correto . Legal!
Para obter o desempenho máximo, o Streamlit narra apenas o que é realmente necessário para atualizar a interface do usuário.O Streamlit foi projetado para funcionar com a GPU. O Streamlit permite que você trabalhe diretamente com o TensorFlow, PyTorch e outras bibliotecas semelhantes. Por exemplo, nesta demonstração, o cache da Streamlit armazena GANs de celebridades da NVIDIA [2]. Isso permite que você obtenha uma resposta quase instantânea ao alterar os valores do controle deslizante.
O aplicativo Streamlit demonstra o
GAN de rostos de celebridades da NVIDIA [2] usando
o TL-GAN de Shaobo Guan [3].
Streamlit é um projeto de código aberto . Você pode distribuir aplicativos livremente no Streamlit sem pedir permissão. Você pode até executar aplicativos no Streamlit localmente sem uma conexão à Internet! E os projetos existentes podem implementar o Streamlit gradualmente.
Várias maneiras de usar o Streamlit. (Os ícones são retirados do fullvector / Freepik .)
E esta é apenas uma visão geral dos recursos do Streamlit. Um dos aspectos mais legais da biblioteca é a facilidade de combinar primitivas em grandes aplicações. Temos mais a dizer sobre a infraestrutura e os planos da Streamlit para o futuro, mas vamos salvá-la para futuras publicações.
Diagrama de componente otimizado. Aguarde mais publicações!Estamos felizes em compartilhar o Streamlit com o mundo e esperamos que, com ele, seus scripts Python ML se transformem em aplicativos completos e completos.
Referências:
[1] J. Redmon e A. Farhadi, YOLOv3: An Incremental Improvement (2018), arXiv.
[2] T. Karras, T. Aila, S. Laine e J. Lehtinen, Crescimento Progressivo de GANs para Melhor Qualidade, Estabilidade e Variação (2018), ICLR.
[3] S. Guan, síntese e edição de imagens controladas usando um novo modelo TL-GAN (2018), Insight Data Science Blog.