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

Otimização de gráfico TensorFlow com Grappler

Ver no TensorFlow.org Executar no Google Colab Ver fonte no GitHub Baixar caderno

Visão geral

O TensorFlow usa gráficos e execuções rápidas para executar cálculos. Um tf.Graph contém um conjunto de tf.Operation objectos (ops) que representam unidades de cálculo e tf.Tensor objectos que representam as unidades de dados que fluem entre ops.

Grappler é o sistema de otimização de gráfico padrão no tempo de execução do TensorFlow. Grappler aplica otimizações em modo gráfico (dentro tf.function ) para melhorar o desempenho de seus cálculos TensorFlow através de simplificações gráfico e outras otimizações de alto nível, tais como inlining corpos de função para ativar otimizações inter-processuais. Optimizar a tf.Graph também reduz a utilização de memória pico dispositivo e melhora a utilização do hardware através da optimização do mapeamento de nodos gráfico aos recursos computacionais.

Use tf.config.optimizer.set_experimental_options() para melhor controle sobre seus tf.Graph otimizações.

Otimizadores de gráfico disponíveis

Executa Grappler gráfico optimizações através de um controlador de nível superior chamado de MetaOptimizer . Os seguintes otimizadores de gráfico estão disponíveis com o TensorFlow:

  • Constante optimizador de dobragem - estaticamente deduz o valor de tensores quando possíveis dobrando nodos constantes no gráfico e se materializa o resultado usando constantes.
  • Otimizador de aritmética - simplifica as operações aritméticas, eliminando subexpressions comuns e simplificando declarações aritméticas.
  • Disposição optimizador - aperfeiçoa tensor layouts para executar operações dependentes do formato de dados, tais como espiras de forma mais eficiente.
  • Remapper Optimizer - Remapeia subgráficos Onto implementações mais eficiente por meio da substituição subgráficos vulgarmente ocorrem com núcleos monolíticos fundidos optimizados.
  • Memory Optimizer - Analisa o gráfico para inspecionar o uso de memória de pico para cada operação e insere operações de cópia de memória CPU-GPU para trocar memória da GPU para CPU para reduzir o uso de memória de pico.
  • Dependência optimizador - Remove ou rearranja controlar dependências de encurtar o caminho crítico para um passo ou modelo permite outras optimizações. Também remove nós que são efetivamente autônomos, como Identidade.
  • Poda Optimizer - nós Prunes que não têm nenhum efeito sobre a saída do gráfico. Geralmente é executado primeiro para reduzir o tamanho do gráfico e acelerar o processamento em outras passagens do Grappler.
  • Função otimizador - otimiza a biblioteca função de um programa TensorFlow e inlines funcionar corpos para permitir que outras otimizações inter-processuais.
  • Forma otimizador - Otimiza subgraphs que operam em forma e moldam as informações relacionadas.
  • Autoparallel optimizador - parallelizes automaticamente gráficos por meio de separação ao longo da dimensão do lote. Este otimizador está DESLIGADO por padrão.
  • Laço optimizador - de optimizar o fluxo de controlo de gráfico de içar subgráficos de loop-out invariante de loops e removendo operações de pilha redundantes em loops. Também otimiza loops com contagens de viagens conhecidas estaticamente e remove ramificações mortas estaticamente conhecidas em condicionais.
  • Escopo de alocador otimizador - introduz escopo allocators para reduzir o movimento de dados e para consolidar algumas operações.
  • Pin para otimizador de acolhimento - Swaps pequenas operações para a CPU. Este otimizador está DESLIGADO por padrão.
  • Auto mista precisão otimizador - tipos de dados converte em float16 quando aplicável para melhorar o desempenho. Atualmente se aplica apenas a GPUs.
  • Depuração extractor - Tiras nodos relacionados com operações de depuração, tais como tf.debugging.Assert , tf.debugging.check_numerics , e tf.print a partir do gráfico. Este otimizador está DESLIGADO por padrão.

Configurar

import numpy as np
import timeit
import traceback
import contextlib


import tensorflow as tf

Crie um gerenciador de contexto para alternar facilmente os estados do otimizador.

@contextlib.contextmanager
def options(options):
  old_opts = tf.config.optimizer.get_experimental_options()
  tf.config.optimizer.set_experimental_options(options)
  try:
    yield
  finally:
    tf.config.optimizer.set_experimental_options(old_opts)

Compare o desempenho de execução com e sem Grappler

TensorFlow 2 e além executa ansiosamente por padrão. Use tf.function para alternar a execução padrão para o modo Graph. O Grappler é executado automaticamente em segundo plano para aplicar as otimizações de gráfico acima e melhorar o desempenho de execução.

Otimizador de dobragem constante

Como um exemplo preliminar, considere uma função que executa operações em constantes e retorna uma saída.

def test_function_1():
  @tf.function
  def simple_function(input_arg):
    print('Tracing!')
    a = tf.constant(np.random.randn(2000,2000), dtype = tf.float32)
    c = a
    for n in range(50):
      c = c@a
    return tf.reduce_mean(c+input_arg)

  return simple_function

Desligue o otimizador de dobra constante e execute a função:

with options({'constant_folding': False}):
  print(tf.config.optimizer.get_experimental_options())
  simple_function = test_function_1()
  # Trace once
  x = tf.constant(2.2)
  simple_function(x)
  print("Vanilla execution:", timeit.timeit(lambda: simple_function(x), number = 1), "s")
{'constant_folding': False, 'disable_model_pruning': False, 'disable_meta_optimizer': False}
Tracing!
Vanilla execution: 0.0018392090000816097 s

Habilite o otimizador de dobra constante e execute a função novamente para observar uma aceleração na execução da função.

with options({'constant_folding': True}):
  print(tf.config.optimizer.get_experimental_options())
  simple_function = test_function_1()
  # Trace once
  x = tf.constant(2.2)
  simple_function(x)
  print("Constant folded execution:", timeit.timeit(lambda: simple_function(x), number = 1), "s")
{'constant_folding': True, 'disable_model_pruning': False, 'disable_meta_optimizer': False}
Tracing!
Constant folded execution: 0.0006749789999958011 s

Otimizador de debug stripper

Considere uma função simples que verifica o valor numérico de seu argumento de entrada e o retorna.

def test_function_2():
  @tf.function
  def simple_func(input_arg):
    output = input_arg
    tf.debugging.check_numerics(output, "Bad!")
    return output
  return simple_func

Primeiro, execute a função com o otimizador de stripper de depuração desligado.

test_func = test_function_2()
p1 = tf.constant(float('inf'))
try:
  test_func(p1)
except tf.errors.InvalidArgumentError as e:
  traceback.print_exc(limit=2)
2021-09-22 20:34:55.871238: E tensorflow/core/kernels/check_numerics_op.cc:292] abnormal_detected_host @0x7f4878e00100 = {0, 1} Bad!
Traceback (most recent call last):
  File "/tmp/ipykernel_22954/3616845043.py", line 4, in <module>
    test_func(p1)
  File "/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow/python/eager/def_function.py", line 885, in __call__
    result = self._call(*args, **kwds)
tensorflow.python.framework.errors_impl.InvalidArgumentError:  Bad! : Tensor had Inf values
     [[node CheckNumerics (defined at tmp/ipykernel_22954/2241890286.py:5) ]] [Op:__inference_simple_func_131]

Errors may have originated from an input operation.
Input Source operations connected to node CheckNumerics:
 input_arg (defined at tmp/ipykernel_22954/3616845043.py:4)

Function call stack:
simple_func

tf.debugging.check_numerics gera um erro de argumento inválido por causa da Inf argumento para test_func .

Habilite o otimizador de stripper de depuração e execute a função novamente.

with options({'debug_stripper': True}):
  test_func2 = test_function_2()
  p1 = tf.constant(float('inf'))
  try:
    test_func2(p1)
  except tf.errors.InvalidArgumentError as e:
    traceback.print_exc(limit=2)

O optimizador de depuração de stripper retira o tf.debug.check_numerics nó a partir do gráfico e executa a função sem levantar quaisquer erros.

Resumo

O tempo de execução do TensorFlow usa Grappler para otimizar gráficos automaticamente antes da execução. Use tf.config.optimizer.set_experimental_options para ativar ou desativar os vários otimizadores gráfico.

Para mais informações sobre Grappler, consulte TensorFlow Gráfico otimizações .