Curso
Introdução ao Python
4 h
7M
Introdução
Ao criar um modelo de machine learning, é comum esquecer a infraestrutura necessária para treinar e disponibilizar o modelo em produção. Em fluxos de trabalho de ML de ponta a ponta, pode ser desafiador gerenciar todas as considerações de aplicação, plataforma e recursos.
Em comparação com implantações web convencionais, aplicações de machine learning têm características diferentes. Por exemplo, a fase de treinamento é intensiva em recursos, enquanto a fase de inferência é mais leve e rápida. Você também vai precisar de ferramentas e frameworks para rodar todas essas partes. Um framework open source muito popular que ajuda a padronizar a entrega de aplicações de ML de ponta a ponta é o Kubeflow.
O que é o Kubeflow?
Kubeflow é um projeto open source que reúne um conjunto curado de ferramentas e frameworks. Seu objetivo principal é facilitar o desenvolvimento, a implantação e o gerenciamento de fluxos de trabalho de machine learning portáteis e escaláveis.
O Kubeflow é construído sobre o Kubernetes, uma plataforma open source para executar e orquestrar contêineres. O Kubernetes foi projetado para rodar de forma consistente em diferentes ambientes, o que é essencial para o funcionamento do Kubeflow. O Kubeflow permite que o Kubernetes faça o que sabe fazer melhor, enquanto você foca em definir e rodar fluxos de trabalho de ML — incluindo gerenciar dados, rodar notebooks, treinar modelos e servi-los.
O Kubeflow evoluiu de um projeto interno do Google chamado TensorFlow Extended. Começou como uma forma mais simples de executar jobs do TensorFlow no Kubernetes, mas hoje é um framework multi-arquitetura e multi-cloud para executar fluxos de trabalho de ML de ponta a ponta.
Kubeflow e fluxos de trabalho de machine learning
O Kubeflow é uma plataforma para cientistas de dados e engenheiros de ML que reúne o melhor dos dois mundos. Cientistas de dados podem usar o Kubeflow para experimentar modelos e orquestrar seus experimentos no Kubernetes da forma mais eficiente.
Engenheiros de ML podem usar o Kubeflow para implantar sistemas de machine learning em vários ambientes de desenvolvimento, teste e produção.
O diagrama abaixo exemplifica duas fases distintas em um projeto de ML: (i) fase experimental e (ii) fase de produção.
O Kubeflow tem vários componentes que cobrem praticamente todas as etapas do pipeline a seguir. Por exemplo, para ajuste de hiperparâmetros, o Kubeflow conta com um componente chamado "Katib". Vamos falar dos principais componentes do Kubeflow mais adiante neste tutorial.
Kubeflow - fluxo de trabalho de machine learning
Instalando o Kubeflow
Existem duas formas de começar a usar o Kubeflow:
- Instalar com uma distribuição empacotada (simples e direto).
- Instalar com manifests (avançado).
As distribuições empacotadas são desenvolvidas e mantidas por seus respectivos responsáveis. Por exemplo, o Kubeflow no Azure é mantido pela Microsoft. Confira a lista completa de distribuições na tabela abaixo:
Distribuições empacotadas do Kubeflow
Três princípios do Kubeflow
Componibilidade
Componibilidade é um princípio de design de sistemas que lida com as inter-relações entre componentes. O Kubeflow é altamente componível, então você pode, por exemplo, usar versões diferentes do TensorFlow em partes distintas do seu pipeline de ML, se precisar.
Portabilidade
Portabilidade significa poder executar todo o seu projeto de ML em qualquer lugar onde o Kubeflow esteja rodando. Ele é agnóstico de plataforma e abstrai as dificuldades para o usuário. Você escreve seu código uma vez, e o Kubeflow cuida da abstração para rodá-lo no seu laptop ou em um cluster na nuvem.
Escalabilidade
Escalabilidade significa que seu projeto consegue acessar mais recursos quando necessário e liberá-los quando não precisa. Cada ambiente pode ter recursos de computação diferentes, como CPUs, GPUs e TPUs.
Entidades conceituais do Kubeflow
Componentes do Kubeflow
Os componentes do Kubeflow são blocos lógicos que, juntos, formam a plataforma. Em um projeto de ML, você provavelmente vai usar um ou mais desses componentes.
Painel
Acima de tudo, o painel central (Central Dashboard) dá acesso rápido aos outros componentes do Kubeflow. Alguns dos mais úteis são:
- Notebooks: para gerenciar servidores de Notebook.
- Pipelines: para gerenciar os pipelines do Kubeflow.
- Experimentos: para gerenciar os experimentos do Katib.
Notebooks
O Kubeflow vem com um ambiente integrado de notebooks Jupyter. Eles são úteis para testes rápidos, desenvolvimento de modelos e até para escrever aplicações de ML.
É comum engenheiros de ML e cientistas de dados rodarem notebooks localmente e ficarem limitados por recursos. Ter notebooks no cluster facilita rodar jobs em que os recursos podem ser escalados dinamicamente.
Pipelines
O Kubeflow Pipelines é um componente poderoso para construir pipelines de ML portáteis e escaláveis, baseados em contêineres Docker, cobrindo todo o processo de ponta a ponta.
Machine Learning Pipelines são um conjunto de etapas que cuidam de tudo, da coleta de dados à disponibilização de modelos em produção. Cada etapa do pipeline é um contêiner Docker — portanto, portátil e escalável. Cada etapa é independente, permitindo o reuso de componentes do pipeline.
Interface do Kubeflow Pipelines
Neste tutorial, vamos explorar em detalhe o componente Kubeflow Pipelines e ver um exemplo de código para criar e executar um pipeline de machine learning com o Kubeflow.
Katib
Katib é um componente do Kubeflow projetado para ajuste automático de hiperparâmetros em escala. O tuning de hiperparâmetros é essencial para desenvolver bons modelos, já que buscar manualmente no espaço de hiperparâmetros pode exigir muito esforço.
O Katib ajuda a otimizar os valores dos hiperparâmetros em torno de uma métrica definida (como AUC ou RMSE). É uma forma prática de encontrar e visualizar a configuração ideal para preparar seu modelo para produção.
Kubeflow Pipelines
Um fluxo de trabalho de ML pode envolver muitas etapas, da preparação dos dados ao treinamento e à avaliação do modelo, entre outras. É difícil acompanhar tudo de forma ad hoc.
Registro de experimentos e versionamento de modelos sem ferramentas adequadas são outros desafios comuns para cientistas de dados. O Kubeflow Pipelines permite desenvolver fluxos de trabalho de ML com padrões componíveis, compartilháveis e reproduzíveis.
O Kubeflow é uma solução nativa do Kubernetes que ajuda cientistas de dados a adotar uma mentalidade disciplinada de pipelines ao desenvolver código de ML e escalá-lo para a nuvem. Os objetivos do Kubeflow Pipelines são:
- Simplificar a orquestração de pipelines de ML em escala.
- Permitir experimentação mais rápida, reprodutibilidade e colaboração por meio de multi-tenancy. A interface do Kubeflow permite criar grupos e adicionar usuários com controle de acesso.
- Ser reutilizável e padronizar diferentes componentes de ML (etapas em pipelines).
Com o Kubeflow, você cria soluções de ML de ponta a ponta sem ter que reconstruir tudo do zero, como se fossem blocos de montar. O Kubeflow também oferece monitoramento de execução, agendamento de workflows, registro de metadados e versionamento.
Visão arquitetural do Kubeflow
Conceitos importantes no Kubeflow Pipelines
Pipeline
Um pipeline é uma sequência de etapas claramente definidas em um fluxo de trabalho de machine learning. O pipeline deve definir os insumos (parâmetros) necessários para rodar e as entradas e saídas de cada componente. Cada componente recebe uma entrada, a processa e fornece a saída para o próximo componente.
Um conceito muito importante aqui é: cada etapa (componente) em um pipeline do Kubeflow é, basicamente, um contêiner Docker. Ao executar um pipeline, o Kubeflow inicia um ou mais Pods do Kubernetes correspondentes aos componentes. Os pods então iniciam o contêiner Docker, que por sua vez executa o código que você escreveu no componente.
Componente
Um componente de pipeline é um código autocontido que executa uma etapa do fluxo de trabalho de ML, como imputação de valores ausentes, escalonamento de dados ou ajuste de um modelo.
Um componente em um pipeline do Kubeflow é semelhante a uma função. Assim, cada componente tem um nome, parâmetros de entrada e uma saída.
Cada componente deve ser empacotado como uma imagem Docker para que cada etapa do pipeline seja independente das demais, permitindo misturar frameworks e ferramentas diferentes em partes distintas do seu fluxo de ML.
Experimento
Um experimento permite rodar configurações diferentes do mesmo pipeline e comparar/analisar os resultados. Normalmente em ML você precisa testar parâmetros variados para ver o que funciona melhor. O experimento do Kubeflow Pipelines foi criado para isso.
Grafo
Um grafo é a representação visual na interface do Kubeflow. Ele mostra as etapas que um run do pipeline executou ou está executando, com setas indicando as relações de dependência entre os componentes representados por cada etapa.
Três maneiras de criar pipelines no Kubeflow
Agora que está claro o que são os pipelines do Kubeflow e seus benefícios para desenhar e implantar fluxos de ML em produção, vamos revisar rapidamente três formas de criar e implantar pipelines.
Interface do usuário (UI)
Você pode usar a UI do Kubeflow para executar pipelines, fazer upload de pipelines compartilhados com você, visualizar artefatos e saídas dos runs e agendar execuções automáticas. A interface do Pipeline é assim:
Interfaces do Kubeflow Pipeline
SDK oficial em Python
O Kubeflow oferece um conjunto de bibliotecas Python para desenvolver e executar pipelines de ML de forma programática. Este é o modo de uso mais comum do Kubeflow Pipelines.
REST API
O Kubeflow também fornece APIs REST para sistemas de integração/entrega contínua. Imagine integrar funcionalidades do Kubeflow Pipelines a sistemas ou processos corporativos downstream.
Tutorial de Kubeflow Pipeline
A forma mais simples de começar com o Kubeflow é usar uma distribuição empacotada, que funciona como um serviço gerenciado na nuvem. Aqui, estamos usando o serviço do Kubeflow no GCP. Você pode seguir este guia oficial para aprender a implantar o serviço no GCP.
Depois da implantação, você acessa este painel pelo endpoint do GCP.
Kubeflow Dashboard - implantação no GCP
O Kubeflow Pipelines traz alguns pipelines de exemplo. Vamos testar um pipeline básico de pré-processamento de dados em Python. Clique em Pipelines na barra lateral esquerda.
Kubeflow Pipelines - implantação no GCP
Clique em criar experimento:
Kubeflow Pipelines - implantação no GCP
Siga as instruções e, na tela de execução, clique em iniciar para rodar o pipeline.
Kubeflow Pipelines - implantação no GCP
O experimento vai aparecer no painel:
Kubeflow Pipelines - implantação no GCP
Clique no experimento para ver a saída quando a execução terminar:
Kubeflow Pipelines - implantação no GCP
Agora que você já viu como executar pipelines usando a UI do Kubeflow: cada componente do pipeline acima é apenas um script Python simples e isolado. No exemplo, as etapas são simples, como “Print Text” ou “Sum Numbers”.
Vamos ver um exemplo mais complexo de como codificar e compilar esses componentes em Python.
Crie um Kubeflow Pipeline pelo SDK em Python
Neste exemplo, vamos criar um pipeline com dois componentes:
- Baixar um arquivo .tar compactado a partir da URL passada como entrada,
- Extrair todos os arquivos CSV e criar um único DataFrame do pandas usando a função `pd.concat`.
Teoricamente, em vez de dividir o pipeline em duas etapas, poderíamos criar uma única função que recebe a URL, baixa o arquivo compactado e depois mescla todos os CSVs em um único arquivo.
Mas, ao fazer em duas etapas, você cria um passo de download reutilizável em outros projetos.
No Kubeflow, você pode definir o componente como um arquivo YAML e usar a função `kfp.components.load_component_from_url` para carregá-lo diretamente pela URL.
Para a primeira etapa, vamos carregar o componente deste link open source.
```
web_downloader_op = kfp.components.load_component_from_url(
'https://raw.githubusercontent.com/kubeflow/pipelines/master/components/web/Download/component-sdk-v2.yaml')
```Na segunda etapa, vamos definir uma função em Python:
```
@component(
packages_to_install=['pandas==1.1.4'],
output_component_file='component.yaml'
)
def merge_csv(tar_data: Input[Artifact], output_csv: Output[Dataset]):
import glob
import pandas as pd
import tarfile
tarfile.open(name=tar_data.path, mode="r|gz").extractall('data')
df = pd.concat(
[pd.read_csv(csv_file, header=None)
for csv_file in glob.glob('data/*.csv')])
df.to_csv(output_csv.path, index=False, header=False)
```Perceba que a função está decorada com a anotação `kfp.dsl.component`. Com ela, definimos a imagem do contêiner, dependências de pacotes (neste exemplo, pandas[1.1.4]) e o local para salvar a especificação do componente (component.yaml)
Agora você pode ligar esses dois componentes em um pipeline usando o operador `pipeline`.
Defina um pipeline e crie uma tarefa a partir de um componente:
@dsl.pipeline(
name='my-pipeline',
# You can optionally specify your own pipeline_root
# pipeline_root='gs://my-pipeline-root/example-pipeline',
)
def my_pipeline(url: str):
web_downloader_task = web_downloader_op(url=url)
merge_csv_task = merge_csv(tar_data=web_downloader_task.outputs['data'])
# The outputs of the merge_csv_task can be referenced using the
# merge_csv_task.outputs dictionary: merge_csv_task.outputs['output_csv']
```Depois de definido o pipeline, podemos compilá-lo. Há duas maneiras de fazer isso. A primeira é pela UI do Kubeflow.
```
kfp.compiler.Compiler(mode=kfp.dsl.PipelineExecutionMode.V2_COMPATIBLE).compile(
pipeline_func=my_pipeline,
package_path='pipeline.yaml')
```Agora podemos fazer upload e executar o arquivo `pipeline.yaml` usando a interface do Kubeflow Pipelines. Alternativamente, podemos rodar o pipeline usando o cliente do SDK do Kubeflow Pipelines.
```
client = kfp.Client()
client.create_run_from_pipeline_func(
my_pipeline,
mode=kfp.dsl.PipelineExecutionMode.V2_COMPATIBLE,
# You can optionally override your pipeline_root when submitting the run too:
# pipeline_root='gs://my-pipeline-root/example-pipeline',
arguments={
'url': 'https://storage.googleapis.com/ml-pipeline-playground/iris-csv-files.tar.gz'
})
```Se quisermos estender esse pipeline para incluir um modelo de ML, criaremos uma função em Python que receba `Input[Dataset]` e ajuste o modelo com o framework desejado, como sklearn, TensorFlow ou PyTorch.
Depois de criar a função, é só editar a função `my_pipeline` para incluir a terceira tarefa e recompilar o pipeline usando `kfp.Client` ou a UI.
Tutorial reproduzido de Kubeflow Official.
Conclusão
Experimentar em um Jupyter Notebook com alguns milhões de linhas é uma coisa. Treinar um modelo de ML com bilhões de linhas remotamente na nuvem é outra. O jogo muda quando precisamos treinar modelos grandes em um ambiente escalável e distribuído.
O Kubernetes é um dos orquestradores mais populares para jobs de ML; e o Kubeflow é um framework construído sobre o Kubernetes para abstrair muitas das complexidades para o usuário. Mas vale lembrar: não é a única opção. Como em tudo, existem alternativas.
Um exemplo desse tipo de plataforma é o Databricks. Ele tem seu próprio mecanismo de orquestração proprietário (diferente do Kubernetes) e oferece uma UI caprichada com suporte a Notebooks, registro de experimentos, registro de modelos, agendamento de jobs e monitoramento.
Amazon Sagemaker é outro exemplo de alternativa ao Kubernetes/Kubeflow. O Amazon SageMaker é um serviço de ML totalmente gerenciado que cientistas de dados e desenvolvedores podem usar para construir e treinar modelos com rapidez e facilidade, e implantá-los diretamente em um ambiente hospedado pronto para produção. Ele fornece um ambiente integrado de Jupyter Notebook para exploração e análise.
Está se sentindo sobrecarregado com tantos conceitos de engenharia que não param de evoluir? Fica tranquilo: a DataCamp oferece o curso Understanding Data Engineering . Nele, você vai aprender as responsabilidades centrais de um engenheiro de dados, como elas diferem das de cientistas de dados e como facilitam o fluxo de dados na organização. Além disso, vai entender como engenheiros de dados preparam o terreno para que cientistas de dados façam seu trabalho. Sem necessidade de código!
