Ajuda a proteger a Grande Barreira de Corais com TensorFlow em Kaggle Junte Desafio

Compreendendo os componentes personalizados do TFX

Os pipelines TFX permitem que você orquestre seu fluxo de trabalho de aprendizado de máquina (ML) em orquestradores, como: Apache Airflow, Apache Beam e Kubeflow Pipelines. Os pipelines organizam seu fluxo de trabalho em uma sequência de componentes, em que cada componente executa uma etapa no fluxo de trabalho de ML. Os componentes padrão TFX fornecem funcionalidade comprovada para ajudá-lo a começar a construir um fluxo de trabalho de ML com facilidade. Você também pode incluir componentes personalizados em seu fluxo de trabalho. Os componentes personalizados permitem que você estenda seu fluxo de trabalho de ML:

  • Construir componentes adaptados para atender às suas necessidades, como a ingestão de dados de um sistema proprietário.
  • Aplicação de aumento, aumento ou redução da resolução de dados.
  • Execute a detecção de anomalias com base em intervalos de confiança ou erro de reprodução do codificador automático.
  • Interface com sistemas externos, como help desks, para alerta e monitoramento.
  • Aplicação de rótulos a exemplos não rotulados.
  • Integração de ferramentas criadas com linguagens diferentes de Python em seu fluxo de trabalho de ML, como a realização de análise de dados usando R.

Ao misturar componentes padrão e componentes personalizados, você pode construir um fluxo de trabalho de ML que atenda às suas necessidades enquanto aproveita as melhores práticas incorporadas aos componentes padrão do TFX.

Este guia descreve os conceitos necessários para entender os componentes personalizados do TFX e as diferentes maneiras de construir componentes personalizados.

Anatomia de um componente TFX

Esta seção fornece uma visão geral de alto nível da composição de um componente TFX. Se você é novo em pipelines TFX, aprenda os principais conceitos lendo o guia para entender os pipelines TFX .

Os componentes TFX são compostos de uma especificação de componente e uma classe de executor que são empacotados em uma classe de interface de componente.

Uma especificação de componente define o contrato de entrada e saída do componente. Este contrato especifica os artefatos de entrada e saída do componente e os parâmetros que são usados ​​para a execução do componente.

A classe do executor de um componente fornece a implementação para o trabalho executado pelo componente.

Uma classe de interface de componente combina a especificação do componente com o executor para uso como um componente em um pipeline TFX.

Componentes TFX em tempo de execução

Quando um pipeline executa um componente TFX, o componente é executado em três fases:

  1. Primeiro, o driver usa a especificação do componente para recuperar os artefatos necessários do armazenamento de metadados e passá-los para o componente.
  2. Em seguida, o Executor executa o trabalho do componente.
  3. Em seguida, o Publicador usa a especificação do componente e os resultados do executor para armazenar as saídas do componente no armazenamento de metadados.

Anatomia do Componente

A maioria das implementações de componentes personalizados não exige que você personalize o driver ou o editor. Normalmente, as modificações no driver e no editor devem ser necessárias apenas se você quiser alterar a interação entre os componentes do pipeline e o repositório de metadados. Se você deseja apenas alterar as entradas, saídas ou parâmetros de seu componente, você só precisa modificar a especificação do componente .

Tipos de componentes personalizados

Existem três tipos de componentes personalizados: componentes baseados em função Python, componentes baseados em contêiner e componentes totalmente personalizados. As seções a seguir descrevem os diferentes tipos de componentes e os casos em que você deve usar cada abordagem.

Componentes baseados em funções Python

Os componentes baseados em funções Python são mais fáceis de construir do que os componentes baseados em contêiner ou componentes totalmente personalizados. A especificação do componente é definida nos argumentos da função Python usando anotações de tipo que descrevem se um argumento é um artefato de entrada, artefato de saída ou um parâmetro. O corpo da função define o executor do componente. A interface do componente é definida adicionando o decorador @component à sua função.

Ao decorar sua função com o decorador @component e definir os argumentos da função com anotações de tipo, você pode criar um componente sem a complexidade de construir uma especificação de componente, um executor e uma interface de componente.

Aprenda a construir componentes baseados em funções Python .

Componentes baseados em contêineres

Os componentes baseados em contêiner fornecem a flexibilidade para integrar o código escrito em qualquer linguagem em seu pipeline, desde que você possa executar esse código em um contêiner do Docker. Para criar um componente baseado em contêiner, você deve construir uma imagem de contêiner do Docker que contenha o código executável do seu componente. Então você deve chamar a função create_container_component para definir:

  • As entradas, saídas e parâmetros de sua especificação de componente.
  • A imagem do contêiner e o comando que o executor do componente executa.

Esta função retorna uma instância de um componente que você pode incluir em sua definição de pipeline.

Essa abordagem é mais complexa do que construir um componente baseado em função Python, uma vez que requer empacotar seu código como uma imagem de contêiner. Essa abordagem é mais adequada para incluir código não Python em seu pipeline ou para construir componentes Python com ambientes de tempo de execução complexos ou dependências.

Aprenda a construir componentes baseados em contêiner .

Componentes totalmente personalizados

Componentes totalmente personalizados permitem que você crie componentes definindo a especificação do componente, o executor e as classes de interface do componente. Essa abordagem permite reutilizar e estender um componente padrão para atender às suas necessidades.

Se um componente existente for definido com as mesmas entradas e saídas que o componente customizado que você está desenvolvendo, você pode simplesmente substituir a classe Executor do componente existente. Isso significa que você pode reutilizar uma especificação de componente e implementar um novo executor que deriva de um componente existente. Dessa forma, você reutiliza a funcionalidade incorporada aos componentes existentes e implementa apenas a funcionalidade necessária.

Se, no entanto, as entradas e saídas de seu novo componente são exclusivas, você pode definir uma especificação de componente totalmente nova.

Essa abordagem é melhor para reutilizar especificações de componentes e executores existentes.

Aprenda a construir componentes totalmente personalizados .