python - modelo - cómo implementar next_batch de tensorflow para datos propios

tensorflow python español

Question

En el tutorial MNIST de tensorflow, la función mnist.train.next_batch(100) es muy útil. Ahora estoy tratando de implementar una clasificación simple a mí mismo. Tengo mis datos de entrenamiento en una matriz numpy. ¿Cómo podría implementar una función similar para mis propios datos para darme el siguiente lote?

sess = tf.InteractiveSession()
tf.global_variables_initializer().run()
Xtr, Ytr = loadData()
for it in range(1000):
    batch_x = Xtr.next_batch(100)
    batch_y = Ytr.next_batch(100)

Answer 1

El enlace que publicaste dice: "obtenemos un" lote "de cien puntos de datos aleatorios de nuestro conjunto de entrenamiento" . En mi ejemplo, uso una función global (no un método como en tu ejemplo), por lo que habrá una diferencia en la sintaxis.

En mi función, deberá pasar el número de muestras que se desea y la matriz de datos.

Aquí está el código correcto, que garantiza que las muestras tengan las etiquetas correctas:

import numpy as np

def next_batch(num, data, labels):
    ''''''
    Return a total of `num` random samples and labels. 
    ''''''
    idx = np.arange(0 , len(data))
    np.random.shuffle(idx)
    idx = idx[:num]
    data_shuffle = [data[ i] for i in idx]
    labels_shuffle = [labels[ i] for i in idx]

    return np.asarray(data_shuffle), np.asarray(labels_shuffle)

Xtr, Ytr = np.arange(0, 10), np.arange(0, 100).reshape(10, 10)
print(Xtr)
print(Ytr)

Xtr, Ytr = next_batch(5, Xtr, Ytr)
print(''/n5 random samples'')
print(Xtr)
print(Ytr)

Y una demostración de ejecución:

[0 1 2 3 4 5 6 7 8 9]
[[ 0  1  2  3  4  5  6  7  8  9]
 [10 11 12 13 14 15 16 17 18 19]
 [20 21 22 23 24 25 26 27 28 29]
 [30 31 32 33 34 35 36 37 38 39]
 [40 41 42 43 44 45 46 47 48 49]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]
 [80 81 82 83 84 85 86 87 88 89]
 [90 91 92 93 94 95 96 97 98 99]]

5 random samples
[9 1 5 6 7]
[[90 91 92 93 94 95 96 97 98 99]
 [10 11 12 13 14 15 16 17 18 19]
 [50 51 52 53 54 55 56 57 58 59]
 [60 61 62 63 64 65 66 67 68 69]
 [70 71 72 73 74 75 76 77 78 79]]

Answer 2

La respuesta que está marcada arriba probé el algoritmo con ese algoritmo. No obtengo resultados, así que busqué en Kaggle y vi un algoritmo realmente asombroso que funcionó muy bien. El mejor resultado prueba esto. En el algoritmo siguiente ** La variable global toma la entrada que declaró anteriormente en la que leyó su conjunto de datos. **

epochs_completed = 0
index_in_epoch = 0
num_examples = X_train.shape[0]
    # for splitting out batches of data
def next_batch(batch_size):

    global X_train
    global y_train
    global index_in_epoch
    global epochs_completed

    start = index_in_epoch
    index_in_epoch += batch_size

    # when all trainig data have been already used, it is reorder randomly    
    if index_in_epoch > num_examples:
        # finished epoch
        epochs_completed += 1
        # shuffle the data
        perm = np.arange(num_examples)
        np.random.shuffle(perm)
        X_train = X_train[perm]
        y_train = y_train[perm]
        # start next epoch
        start = 0
        index_in_epoch = batch_size
        assert batch_size <= num_examples
    end = index_in_epoch
    return X_train[start:end], y_train[start:end]

Answer 3

Para mezclar y muestrear cada mini-lote, también se debe considerar el estado de si una muestra ha sido seleccionada dentro de la época actual. Aquí hay una implementación que utiliza los datos de la respuesta anterior.

import numpy as np 

class Dataset:

def __init__(self,data):
    self._index_in_epoch = 0
    self._epochs_completed = 0
    self._data = data
    self._num_examples = data.shape[0]
    pass


@property
def data(self):
    return self._data

def next_batch(self,batch_size,shuffle = True):
    start = self._index_in_epoch
    if start == 0 and self._epochs_completed == 0:
        idx = np.arange(0, self._num_examples)  # get all possible indexes
        np.random.shuffle(idx)  # shuffle indexe
        self._data = self.data[idx]  # get list of `num` random samples

    # go to the next batch
    if start + batch_size > self._num_examples:
        self._epochs_completed += 1
        rest_num_examples = self._num_examples - start
        data_rest_part = self.data[start:self._num_examples]
        idx0 = np.arange(0, self._num_examples)  # get all possible indexes
        np.random.shuffle(idx0)  # shuffle indexes
        self._data = self.data[idx0]  # get list of `num` random samples

        start = 0
        self._index_in_epoch = batch_size - rest_num_examples #avoid the case where the #sample != integar times of batch_size
        end =  self._index_in_epoch  
        data_new_part =  self._data[start:end]  
        return np.concatenate((data_rest_part, data_new_part), axis=0)
    else:
        self._index_in_epoch += batch_size
        end = self._index_in_epoch
        return self._data[start:end]

dataset = Dataset(np.arange(0, 10))
for i in range(10):
    print(dataset.next_batch(5))

la salida es:

[2 8 6 3 4]
[1 5 9 0 7]
[1 7 3 0 8]
[2 6 5 9 4]
[1 0 4 8 3]
[7 6 2 9 5]
[9 5 4 6 2]
[0 1 8 7 3]
[9 7 8 1 6]
[3 5 2 4 0]

el primer y segundo (3ro y 4to, ...) mini lote corresponden a una época completa ..

Answer 4

Si no desea obtener un error de desajuste de forma en la ejecución de la sesión de tensorflow, utilice la función siguiente en lugar de la función que se proporciona en la primera solución anterior ( https://.com/a/40995666/7748451 ) -

def next_batch(num, data, labels):

    ''''''
    Return a total of `num` random samples and labels. 
    ''''''
    idx = np.arange(0 , len(data))
    np.random.shuffle(idx)
    idx = idx[:num]
    data_shuffle = data[idx]
    labels_shuffle = labels[idx]
    labels_shuffle = np.asarray(labels_shuffle.values.reshape(len(labels_shuffle), 1))

    return data_shuffle, labels_shuffle

Answer 5

Yo uso Anaconda y Jupyter. En Jupyter, si ejecuta ?mnist obtendrá: File: c:/programdata/anaconda3/lib/site-packages/tensorflow/contrib/learn/python/learn/datasets/base.py Docstring: Datasets(train, validation, test)

En los conjuntos de datesets carpeta, encontrará mnist.py que contiene todos los métodos, incluido next_batch .