Treinar em lotes no Tensorflow

Atualmente, estou tentando treinar um modelo em um arquivo csv grande (> 70 GB com mais de 60 milhões de linhas). Para fazer isso, estou usando tf.contrib.learn.read_batch_examples. Estou lutando para entender como essa função realmente lê os dados. Se estou usando um tamanho de lote de, por exemplo, 50.000, ele lê as primeiras 50.000 linhas do arquivo? Se eu quiser fazer um loop sobre o arquivo inteiro (1 época), tenho que usar o número num_rows / batch_size = 1.200 número de etapas para o método estimator.fit?

Aqui está a função de entrada que estou usando atualmente:

def input_fn(file_names, batch_size):
    # Read csv files and create examples dict
    examples_dict = read_csv_examples(file_names, batch_size)

    # Continuous features
    feature_cols = {k: tf.string_to_number(examples_dict[k],
                                           out_type=tf.float32) for k in CONTINUOUS_COLUMNS}

    # Categorical features
    feature_cols.update({
                            k: tf.SparseTensor(
                                indices=[[i, 0] for i in range(examples_dict[k].get_shape()[0])],
                                values=examples_dict[k],
                                shape=[int(examples_dict[k].get_shape()[0]), 1])
                            for k in CATEGORICAL_COLUMNS})

    label = tf.string_to_number(examples_dict[LABEL_COLUMN], out_type=tf.int32)

    return feature_cols, label


def read_csv_examples(file_names, batch_size):
    def parse_fn(record):
        record_defaults = [tf.constant([''], dtype=tf.string)] * len(COLUMNS)

        return tf.decode_csv(record, record_defaults)

    examples_op = tf.contrib.learn.read_batch_examples(
        file_names,
        batch_size=batch_size,
        queue_capacity=batch_size*2.5,
        reader=tf.TextLineReader,
        parse_fn=parse_fn,
        #read_batch_size= batch_size,
        #randomize_input=True,
        num_threads=8
    )

    # Important: convert examples to dict for ease of use in `input_fn`
    # Map each header to its respective column (COLUMNS order
    # matters!
    examples_dict_op = {}
    for i, header in enumerate(COLUMNS):
        examples_dict_op[header] = examples_op[:, i]

    return examples_dict_op

Aqui está o código que estou usando para treinar o modelo:

def train_and_eval():
"""Train and evaluate the model."""

m = build_estimator(model_dir)
m.fit(input_fn=lambda: input_fn(train_file_name, batch_size), steps=steps)

O que aconteceria se eu chamasse a função fit novamente com o mesmo input_fn. Ele começa no início do arquivo novamente ou será lembrado da linha em que parou da última vez?

Como ainda não há resposta, quero tentar dar uma resposta pelo menos de alguma forma útil. A inclusão das definições de constantes ajudaria um pouco a entender o código fornecido.

De um modo geral, um lote usa n vezes um registro ou item. Como você define um item depende do seu problema. No fluxo tensorial, o lote é codificado na primeira dimensão de um tensor. No seu caso, com o arquivo csv, pode ser linha por linha ( reader=tf.TextLineReader). Poderia aprender por coluna, mas não acho que isso esteja acontecendo no seu código. Se você deseja treinar com todo o conjunto de dados (= uma época ), pode fazê-lo usando numBatches=numItems/batchSize.