Platform For AI:Perguntas frequentes sobre TensorFlow

Sumário

Como referenciar vários arquivos Python?

Para referenciar funções entre arquivos, empacote todos os arquivos Python (por exemplo, test1.py e test2.py) em um arquivo .tar.gz e envie-o. Onde:

• Python Code File: O pacote .tar.gz.

• Main Python File: O arquivo de entrada principal.

Como enviar dados para o OSS?

Os dados de deep learning ficam armazenados em buckets do OSS. Crie um bucket na mesma região do cluster GPU para usar a rede clássica e evitar taxas de tráfego. Em seguida, crie pastas, organize os dados ou envie arquivos pelo console do OSS.

Como ler dados do OSS?

O Python não suporta nativamente caminhos do OSS. Operações padrão de arquivo, como Open(), os.path.exist(), Scipy.misc.imread() e numpy.load(), não funcionam diretamente no OSS.

Use um dos métodos a seguir para ler dados no PAI:

• Use as funções tf.gfile para operações simples de leitura, como ler uma única imagem ou arquivo de texto.

  tf.gfile.Copy(oldpath, newpath, overwrite=False) # Copies a file.
  tf.gfile.DeleteRecursively(dirname) # Recursively deletes all files in a directory.
  tf.gfile.Exists(filename) # Checks if a file exists.
  tf.gfile.FastGFile(name, mode='r') # Reads a file without blocking.
  tf.gfile.GFile(name, mode='r') # Reads a file.
  tf.gfile.Glob(filename) # Lists all files in a folder. Supports patterns.
  tf.gfile.IsDirectory(dirname) # Returns whether dirname is a directory.
  tf.gfile.ListDirectory(dirname) # Lists all files under dirname.
  tf.gfile.MakeDirs(dirname) # Creates a folder under dirname. If the parent directory does not exist, it is automatically created. If the folder already exists and is writable, the operation succeeds.
  tf.gfile.MkDir(dirname) # Creates a folder at dirname.
  tf.gfile.Remove(filename) # Deletes filename.
  tf.gfile.Rename(oldname, newname, overwrite=False) # Renames a file.
  tf.gfile.Stat(dirname) # Returns statistics for a directory.
  tf.gfile.Walk(top, inOrder=True) # Returns the file tree of a directory.

• Use tf.gfile.Glob, tf.gfile.FastGFile, tf.WholeFileReader() e tf.train.shuffle_batch() para leitura em lotes. Primeiro obtenha a lista de arquivos e depois crie o lote.

import tensorflow as tf
FLAGS = tf.flags.FLAGS
tf.flags.DEFINE_string('buckets', 'oss://{OSS Bucket}/', 'The folder where the training images are stored')
tf.flags.DEFINE_string('batch_size', '15', 'The batch size')
files = tf.gfile.Glob(os.path.join(FLAGS.buckets,'*.jpg')) # Lists the paths of all JPG files in the buckets.

Escolha o método de leitura em lotes com base no tamanho do arquivo:

• Para arquivos pequenos, use tf.gfile.FastGFile().

  for path in files:
      file_content = tf.gfile.FastGFile(path, 'rb').read() # Make sure to use 'rb' to read the file. Otherwise, errors may occur in many cases.
      image = tf.image.decode_jpeg(file_content, channels=3) # This example uses a JPG image.

• Para arquivos grandes, use tf.WholeFileReader().

  reader = tf.WholeFileReader()  # Instantiates the reader.
  fileQueue = tf.train.string_input_producer(files)  # Creates a queue for the reader.
  file_name, file_content = reader.read(fileQueue)  # Reads a file from the queue.
  image_content = tf.image.decode_jpeg(file_content, channels=3)  # Decodes the read result into an image.
  label = XXX  # The process of handling the label is omitted.
  batch = tf.train.shuffle_batch([label, image_content], batch_size=FLAGS.batch_size, num_threads=4,
                                 capacity=1000 + 3 * FLAGS.batch_size, min_after_dequeue=1000)
  sess = tf.Session()  # Creates a session.
  tf.train.start_queue_runners(sess=sess)  # Starts the queue. If you do not run this command, the thread remains blocked.
  labels, images = sess.run(batch)  # Obtains the result.

  Código principal:

  • tf.train.string_input_producer: Converte uma lista de nomes de arquivo em uma fila. Chame tf.train.start_queue_runners para iniciar as threads de processamento da fila.

  • Parâmetros de tf.train.shuffle_batch:

    • batch_size: Quantidade de entradas de dados retornadas por operação de lote.

    • num_threads: Número de threads usadas para enfileirar dados. Um valor típico é 4.

    • capacity: Tamanho máximo da fila, que define o intervalo de embaralhamento aleatório. Por exemplo, para embaralhar a partir de um buffer de 5.000 em um conjunto de dados de 10.000 entradas, defina capacity como 5000.

    • min_after_dequeue: Número mínimo de elementos retidos após um dequeue, garantindo um nível mínimo de mistura. Não deve exceder capacity.

Como gravar dados no OSS?

Grave dados no OSS usando um dos métodos abaixo. Nestes exemplos, a saída é armazenada em /model/example.txt:

• Grave dados com tf.gfile.FastGFile():

  tf.gfile.FastGFile(FLAGS.checkpointDir + 'example.txt', 'wb').write('hello world')

• Copie um arquivo local para o OSS usando tf.gfile.Copy():

  tf.gfile.Copy('./example.txt', FLAGS.checkpointDir + 'example.txt')

Por que ocorre um erro OOM durante a execução?

O erro OOM acontece quando o uso de memória ultrapassa 30 GB. Use gfile para transmitir dados do OSS em fluxo contínuo, em vez de carregar conjuntos de dados inteiros na memória. Como ler dados do OSS?.

Quais são alguns exemplos de casos de uso do TensorFlow?

Composição musical: Code for the song composition example.

Qual é a finalidade de model_average_iter_interval quando duas GPUs estão configuradas?

Sem model_average_iter_interval, as GPUs executam o Parallel-SGD padrão e trocam atualizações de gradiente a cada iteração. Quando definido com um valor maior que 1, o Model Average é usado — os parâmetros do modelo são calculados pela média entre ambas as GPUs a cada model_average_iter_interval iterações.

Como exportar um modelo TensorFlow como SavedModel?

Formato SavedModel

Para implantar um modelo TensorFlow como serviço online usando o processor pré-construído oficial no EAS, exporte-o para o formato SavedModel, recomendado oficialmente pelo TensorFlow. A estrutura de diretórios é a seguinte.

assets/
variables/
    variables.data-00000-of-00001
    variables.index
saved_model.pb|saved_model.pbtxt

Onde:

• assets: Pasta opcional que armazena arquivos auxiliares necessários para previsão, como arquivos de vocabulário.

• variables: Armazena as informações de variáveis salvas por tf.train.Saver.

• saved_model.pb ou saved_model.pbtxt: Armazena o MetaGraphDef, que contém a estrutura do grafo do modelo treinado, e o SignatureDef, que especifica as entradas e saídas para previsão.

Exportar um SavedModel

O guia do TensorFlow Saving and Restoring aborda a exportação de SavedModel em detalhes. Para modelos simples, use o método rápido a seguir.

tf.saved_model.simple_save(
  session,
  "./savedmodel/",
  inputs={"image": x},   ## x is the input variable of the model.
  outputs={"scores": y}  ## y is the output of the model.
)

Ao solicitar previsões online, especifique o signature_name do modelo. Para modelos exportados com simple_save(), o signature_name padrão é serving_default.

Para modelos complexos, exporte manualmente para SavedModel:

print('Exporting trained model to', export_path)
builder = tf.saved_model.builder.SavedModelBuilder(export_path)
tensor_info_x = tf.saved_model.utils.build_tensor_info(x)
tensor_info_y = tf.saved_model.utils.build_tensor_info(y)

prediction_signature = (
    tf.saved_model.signature_def_utils.build_signature_def(
        inputs={'images': tensor_info_x},
        outputs={'scores': tensor_info_y},
        method_name=tf.saved_model.signature_constants.PREDICT_METHOD_NAME)
)

legacy_init_op = tf.group(tf.tables_initializer(), name='legacy_init_op')

builder.add_meta_graph_and_variables(
    sess, [tf.saved_model.tag_constants.SERVING],
    signature_def_map={
        'predict_images': prediction_signature,
    },
    legacy_init_op=legacy_init_op
)

builder.save()
print('Done exporting!')

Onde:

• export_path especifica o caminho para o qual o modelo será exportado.

• prediction_signature: O SignatureDef para as entradas e saídas do modelo (SignatureDef). Neste exemplo, o signature_name é predict_images.

• builder.add_meta_graph_and_variables: Especifica os parâmetros de exportação.

Converter um modelo Keras para SavedModel

O método model.save() do Keras exporta no formato H5. Converta para SavedModel para previsão online carregando o modelo H5 com load_model() e reexportando:

import tensorflow as tf
with tf.device("/cpu:0"):
    model = tf.keras.models.load_model('./mnist.h5')
    tf.saved_model.simple_save(
      tf.keras.backend.get_session(),
      "./h5_savedmodel/",
      inputs={"image": model.input},
      outputs={"scores": model.output}
    )

Converter um checkpoint para SavedModel

Modelos de checkpoint salvos com tf.train.Saver() precisam ser convertidos para SavedModel para previsão online. Carregue o checkpoint com saver.restore() e reexporte:

import tensorflow as tf
# variable define ...
saver = tf.train.Saver()
with tf.Session() as sess:
  # Initialize v1 since the saver will not.
    saver.restore(sess, "./lr_model/model.ckpt")
    tensor_info_x = tf.saved_model.utils.build_tensor_info(x)
    tensor_info_y = tf.saved_model.utils.build_tensor_info(y)
    tf.saved_model.simple_save(
      sess,
      "./savedmodel/",
      inputs={"image": tensor_info_x},
      outputs={"scores": tensor_info_y}
    )