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

Entendendo 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 em seu 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.
  • Realize 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 para pipelines TFX, aprender os conceitos fundamentais, lendo o guia para pipelines TFX compreensão .

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 componente define contrato de entrada e de 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.

Classe executor de um componente fornece a implementação para o trabalho realizado pelo componente.

A classe de interface de componente combina a especificação componente com o executor para uso como um componente em um oleoduto 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 repositório 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 repositório 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ê só deseja alterar as entradas, saídas, ou parâmetros para o componente que você só precisa modificar a especificação 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 é definido pela adição do @component decorador para a sua função.

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

Aprenda a construir componentes baseados em função 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 Docker que contenha o código executável do seu componente. Em seguida, você deve chamar o create_container_component função de 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 na definição do 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êineres .

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, contudo, as entradas e saídas do seu novo componente são exclusivos, você pode definir uma inteiramente nova especificação de componente.

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

Aprenda a construir plenamente componentes personalizados .