Tensorflow estendido (TFX) em ação: construir um pipeline de aprendizado profundo de produção de produção

Neste tutorial, exploraremos o TensorFlow Extended (TFX). O TFX foi desenvolvido pelo Google como uma plataforma de ponta a ponta para implantar pipelines de produção ML. Aqui veremos como podemos construir um do zero. Exploraremos os diferentes componentes internos que podemos usar, que cobrem todo o ciclo de vida do aprendizado de máquina. Da pesquisa e desenvolvimento ao treinamento e implantação.

Mas primeiro, vamos começar com alguns conceitos básicos e terminologia para garantir que todos estamos na mesma página.

Eu recomendo o ML Pipelines no Google Cloud Curso da equipe do Google Cloud ou do Cenários de implantação avançada com tensorflow por deeplearning.ai para melhorar suas habilidades com um curso holístico.

Glossário de TFX

Componentes são os blocos de construção de um pipeline e são os que realizam todo o trabalho. Os componentes podem ser usados ​​intactos ou substituídos com nosso próprio código.

Loja de metadados é a única fonte de verdade para todos os componentes. Ele contém 3 coisas basicamente:

• Artefatos e suas propriedades: podem ser modelos, dados, métricas treinados

• Registros de execução de componentes e pipelines

• Metadados sobre o fluxo de trabalho (ordem dos componentes, entradas, saídas, etc)

TFX Pipeline é uma implementação portátil de um fluxo de trabalho ML composto por instâncias de componentes e parâmetros de entrada

Orquestradores são sistemas que executam pipelines TFX. São basicamente plataformas para autor, agendar e monitorar fluxos de trabalho. Eles geralmente representam um pipeline como um gráfico acíclico direcionado e garantem que cada trabalho (ou um trabalhador) seja executado no momento correto com a entrada correta.

Exemplos de orquestradores populares que trabalham com TFX são Fluxo de ar ApacheAssim, Feixe apacheAssim, Kubeflow Pipelines

Com base nos diferentes estágios do ciclo de vida do aprendizado de máquina, o TFX fornece um conjunto de diferentes componentes com funcionalidade padrão. Esses componentes podem ser substituídos. Por exemplo, podemos querer estender sua funcionalidade. Eles também podem ser substituídos por inteiramente novos. Na maioria dos casos, porém, os componentes embutidos levarão a maioria de nós um longo caminho para baixo.

Vamos fazer um passo rápido em todos eles começando com o carregamento de dados e terminando para a implantação. Observe que não vamos mergulhar profundamente no código, porque existem muitas novas bibliotecas e pacotes com os quais a maioria não está familiarizada.

O ponto principal é fornecer uma visão geral do TFX e de seus módulos e ajudá-lo a entender por que precisamos dessas soluções de ponta a ponta

Ingestão de dados

A primeira fase do processo de desenvolvimento de ML é o carregamento de dados. O ExampleGen componentes ingerir dados em um pipeline TFX, convertendo diferentes tipos de dados para tf.Record ou tf.Example (ambos suportados pelo TFX). O código de amostra pode ser encontrado abaixo:

from tfx.proto import example_gen_pb2
from tfx.components import ImportExampleGen
input_config = example_gen_pb2.Input(splits=(
     example_gen_pb2.Input.Split(name='train', pattern='train/*'),
     example_gen_pb2.Input.Split(name='eval', pattern='test/*')
 ))
example_gen = ImportExampleGen(
     input_base=data_root, input_config=input_config)

ImportExampleGen é um tipo especial de ExampleGen Isso recebe um caminho de dados e uma configuração sobre como lidar com nossos dados. Nesse caso, os dividimos em conjuntos de dados de treinamento e teste.

Validação de dados

O próximo passo é explorar nossos dados, visualizá -los e validá -los para possíveis imprecisões e anomalias.

O StatisticsGen O componente gera um conjunto de estatísticas úteis que descrevem nossa distribuição de dados. Como você pode ver, recebe a saída de ExampleGen

from tfx.components import StatisticsGen
statistics_gen = StatisticsGen(examples=example_gen.outputs('examples'))

Validação de dados do tensorflow é uma biblioteca TFX integrada que, entre outras coisas, pode nos ajudar a visualizar as estatísticas produzidas por StatisticsGen. É usado internamente por StatisticsGen mas também pode ser usado como uma ferramenta independente.

import tensorflow_data_validation as tfdv
tfdv.visualize_statistics(stats)

A mesma biblioteca está sendo usada por SchemaGenque gerou um esquema primitivo para nossos dados. É claro que isso pode ser ajustado com base no conhecimento do nosso domínio, mas é um ponto de partida decente.

from tfx.components import SchemaGen
schema_gen = SchemaGen( statistics=statistics_gen.outputs('statistics'), infer_feature_shape=True)

O esquema e as estáticas produzidas agora podem ser utilizadas para realizar alguma forma de validação de dados Isso capturará outliers, anomalias e erros em nosso conjunto de dados.

from tfx.components import ExampleValidator
example_validator = ExampleValidator(
      statistics=statistics_gen.outputs('statistics'),
      schema=schema_gen.outputs('schema'))

Engenharia de recursos

Uma das etapas mais importantes em qualquer pipeline de ML é a engenharia de recursos. Basicamente, pré -processamos nossos dados para que possam ser transmitidos para o nosso modelo. O TFX fornece o Transform componente e o tensorflow_transform Biblioteca para nos ajudar com a tarefa. A etapa de transformação pode ser realizada assim:

from tfx.components import Transform
 transform = Transform(
      examples=example_gen.outputs('examples'),
      schema=schema_gen.outputs('schema'),
      module_file=module_file)

Mas essa não é a história toda.

Precisamos definir nossa funcionalidade de pré -processamento de alguma forma. É aqui que o argumento module_file entra. A maneira mais comum de fazer isso é ter um arquivo diferente com todas as nossas transformações. Essencialmente, precisamos implementar um preprocessing_fn Função que é o ponto de entrada para TFX.

Aqui está uma amostra que emprestei dos exemplos oficiais de TFX:

def preprocessing_fn(inputs):
  """tf.transform's callback function for preprocessing inputs."""
  outputs = {}
   image_features = tf.map_fn(
      lambda x: tf.io.decode_png(x(0), channels=3),
      inputs(_IMAGE_KEY),
      dtype=tf.uint8)
  image_features = tf.cast(image_features, tf.float32)
  image_features = tf.image.resize(image_features, (224, 224))
  image_features = tf.keras.applications.mobilenet.preprocess_input(
      image_features)
  outputs(_transformed_name(_IMAGE_KEY)) = image_features
  outputs(_transformed_name(_LABEL_KEY)) = inputs(_LABEL_KEY)
  return outputs

Código Normal Tensorflow e Keras, como você pode ver.

Treinamento modelo

Treinar o modelo é uma parte vital do processo e, em contraste com o que muitas pessoas acreditam, não é uma operação única.

Os modelos precisam ser atualizados constantemente para permanecer relevante e garantir a melhor precisão possível em seus resultados.

from tfx.dsl.components.base import executor_spec
from tfx.proto import trainer_pb2
from tfx.components.trainer.executor import GenericExecutor
from tfx.components import Trainer
 trainer = Trainer(
      module_file=module_file,
      custom_executor_spec=executor_spec.ExecutorClassSpec(GenericExecutor),
      examples=transform.outputs('transformed_examples'),
      transform_graph=transform.outputs('transform_graph'),
      schema=schema_gen.outputs('schema'),
      train_args=trainer_pb2.TrainArgs(num_steps=160),
      eval_args=trainer_pb2.EvalArgs(num_steps=4),
      custom_config={'labels_path': labels_path})

Como antes, a lógica de treinamento está em um arquivo de módulo separado. Desta vez, temos que implementar o run_fn função, que normalmente define o modelo e o loop de treinamento. Novamente emprestado dos exemplos oficiais e despojado de algumas coisas desnecessárias, aqui está um exemplo:

import tensorflow_transform as tft
def run_fn(fn_args: FnArgs):
  tf_transform_output = tft.TFTransformOutput(fn_args.transform_output)
  train_dataset = _input_fn(
      fn_args.train_files,
      tf_transform_output,
      is_train=True,
      batch_size=_TRAIN_BATCH_SIZE)
  eval_dataset = _input_fn(
      fn_args.eval_files,
      tf_transform_output,
      is_train=False,
      batch_size=_EVAL_BATCH_SIZE)
  model, base_model = _build_keras_model()
  model.compile(
      loss='sparse_categorical_crossentropy',
      optimizer=tf.keras.optimizers.RMSprop(lr=_FINETUNE_LEARNING_RATE),
      metrics=('sparse_categorical_accuracy'))
  model.summary(print_fn=absl.logging.info)
  model.fit(
      train_dataset,
      epochs=_CLASSIFIER_EPOCHS,
      steps_per_epoch=steps_per_epoch,
      validation_data=eval_dataset,
      validation_steps=fn_args.eval_steps,
      callbacks=(tensorboard_callback))

Observe que o _build_keras_model Retorna uma baunilha tf.keras.Sequential modelo, enquanto input_fn Retorna um conjunto de dados em lotes de exemplos de treinamento e etiquetas.

Verifique o Repo Official Git Para o código completo. Também certifique -se de que, com os retornos de chamada corretos, podemos aproveitar Tensorfboard para visualizar o progresso do treinamento.

Validação do modelo

O próximo na linha é a validação do modelo. Depois de treinarmos um modelo, temos que avaliá -lo e analisar seu desempenho antes de empurrá -lo para a produção. Análise do modelo Tensorflow (TFMA) é uma biblioteca para essa coisa em particular. Observe aqui que essa avaliação real do modelo já aconteceu durante o treinamento.

Esta etapa pretende registrar as métricas de avaliação para futuras execuções e compará -las com os modelos anteriores.

Dessa forma, podemos ter certeza de que nosso modelo atual é o melhor que temos no momento.

Não vou entrar nos detalhes do TFMA, mas aqui está algum código para referência futura:

import tensorflow_model_analysis as tfma
 eval_config = tfma.EvalConfig(
      model_specs=(tfma.ModelSpec(label_key='label_xf',      model_type='tf_lite')),
      slicing_specs=(tfma.SlicingSpec()),
      metrics_specs=(
          tfma.MetricsSpec(metrics=(
              tfma.MetricConfig(
                  class_name='SparseCategoricalAccuracy',
                  threshold=tfma.MetricThreshold(
                      value_threshold=tfma.GenericValueThreshold(
                          lower_bound={'value': 0.55}),
                      change_threshold=tfma.GenericChangeThreshold(
                          direction=tfma.MetricDirection.HIGHER_IS_BETTER,
                          absolute={'value': -1e-3})))
          ))
      ))

A parte importante é onde definimos Evaluator componente como parte do nosso pipeline

from tfx.components import Evaluator
evaluator = Evaluator(
      examples=transform.outputs('transformed_examples'),
      model=trainer.outputs('model'),
      baseline_model=model_resolver.outputs('model'),
      eval_config=eval_config)

Empurre o modelo

Quando a validação do modelo é bem -sucedida, é hora de empurrar o modelo para a produção. Este é o trabalho do Pusher Componente, que lida com todas as coisas de implantação, dependendo do nosso ambiente.

from tfx.components import Pusher
 pusher = Pusher(
      model=trainer.outputs('model'),
      model_blessing=evaluator.outputs('blessing'),
      push_destination=pusher_pb2.PushDestination(
          filesystem=pusher_pb2.PushDestination.Filesystem(
              base_directory=serving_model_dir)))

Construa um pipeline TFX

Ok, definimos vários componentes até agora que contêm tudo o que precisamos. Mas como os amarramos? Os pipelines TFX são definidos usando o pipeline classe, que recebe uma lista de componentes, entre outras coisas.

from tfx.orchestration import metadata
from tfx.orchestration import pipeline
  components = (
      example_gen, statistics_gen, schema_gen, example_validator,      transform,
      trainer, model_resolver, evaluator, pusher
  )
  pipeline = pipeline.Pipeline(
      pipeline_name=pipeline_name,
      pipeline_root=pipeline_root,
      components=components,
      enable_cache=True)

As instâncias dos componentes produzem artefatos como saídas e geralmente dependem de artefatos produzidos por instâncias de componentes a montante como entrada. A ordem de execução dos componentes é determinada por um gráfico acíclico direto (DAG) com base nas dependências de cada artefato. Aqui está um pipeline típico de TFX:

Fonte: Google Cloud Platform Docs

Execute um pipeline TFX

Por fim, chegamos à parte em que executaremos o pipeline. Como já dissemos, os pipelines são executados por um orquestrador, que lidará com todo o agendamento de empregos e a rede. Aqui eu escolhi o feixe de apache usando BeamDagRunner Mas os mesmos princípios são verdadeiros para Kubeflow ou fluxo de ar.

from tfx.orchestration.beam.beam_dag_runner import BeamDagRunner
if __name__ == '__main__':
    BeamDagRunner().run( pipeline)

Além disso, devo mencionar que comandos semelhantes podem ser executados a partir da linha de comando usando o TFX CLI.

Tenho certeza de que não é preciso dizer que orquestradores como Apache Beam em 99% dos casos de uso serão executados nuvem recursos.

Isso significa que o feixe aumentará as instâncias/trabalhadores da nuvem e transmitirá dados através deles. Isso dependendo do meio ambiente e do pipeline.

Os corredores típicos abaixo do feixe Apache incluem Spark, Flink, Google DataFlow. Por outro lado, estruturas como Kubeflow confiam Kubernetes. Portanto, um trabalho importante dos engenheiros da MLOPs é encontrar o melhor ambiente para suas necessidades.

Conclusão

Os sistemas de aprendizado de máquina de ponta a ponta ganharam muita atenção nos últimos anos. O MLOPS está começando a se tornar cada vez mais relevante, pois muitas startups e estruturas diferentes nasceram. Um exemplo perfeito é o TFX. Eu tenho que admitir que a construção desses dutos não é uma tarefa fácil e requer um mergulho profundo nos meandros do TFX. Mas acho que é uma das melhores ferramentas que temos em nosso arsenal no momento. Portanto, da próxima vez que você quiser implantar um modelo de aprendizado de máquina, talvez valha a pena dar uma chance.

Como nota lateral, eu tenho que levá -lo novamente a ML Pipelines no Google Cloud Curso da equipe do Google Cloud ou do Cenários de implantação avançada com tensorflow por deeplearning.ai.

* Divulgação: Observe que alguns dos links acima podem ser links de afiliados e, sem custo adicional, ganharemos uma comissão se você decidir fazer uma compra depois de clicar.