it-swarm.com.de

wie man den next_batch von tensorflow für eigene Daten implementiert

Im tensorflow MNIST Tutorial ist die Funktion mnist.train.next_batch(100) sehr praktisch. Ich versuche jetzt, eine einfache Klassifizierung selbst zu implementieren. Ich habe meine Trainingsdaten in einem numpy Array. Wie könnte ich eine ähnliche Funktion für meine eigenen Daten implementieren, um die nächste Charge zu erhalten?

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)
24
blckbird

Der Link, den Sie gepostet haben, lautet: "Wir erhalten einen" Stapel "von hundert zufälligen Datenpunkten aus unserem Trainingssatz" . In meinem Beispiel verwende ich eine globale Funktion (keine Methode wie in Ihrem Beispiel), sodass es einen Unterschied in der Syntax gibt.

In meiner Funktion müssen Sie die Anzahl der gewünschten Samples und das Datenarray übergeben.

Hier ist der richtige Code, der sicherstellt, dass die Proben die richtigen Etiketten haben:

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)

Und ein Demo-Lauf:

[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]]
22
edo

Um jede Mini-Charge zu mischen und zu probieren, sollte auch der Status berücksichtigt werden, ob innerhalb der aktuellen Epoche eine Probe ausgewählt wurde. Hier ist eine Implementierung, die die Daten in der obigen Antwort verwendet. 

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))

die Ausgabe ist:

[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]

die erste und zweite (3. und 4., ...) Mini-Charge entsprechen einer ganzen Epoche.

10
Brother_Mumu

Die Antwort, die oben markiert ist, habe ich ausprobiert. Ich habe den Algorithmus mit diesem Algorithmus ausprobiert. Ich bekomme keine Ergebnisse, also suchte ich nach Kaggle und sah wirklich erstaunliche Algorithmen, die wirklich gut funktionierten. Bestes Ergebnis versuchen Sie dies. Im unteren Algorithmus ** Globale Variable nimmt die Eingabe an, die Sie oben deklariert haben, in der Sie Ihren Datensatz lesen. ** 

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]
1
Sohaib Anwaar

Ich verwende Anaconda und Jupyter . Wenn Sie ?mnist ausführen, erhalten Sie in Jupyter: File: c:\programdata\anaconda3\lib\site-packages\tensorflow\contrib\learn\python\learn\datasets\base.py Docstring: Datasets(train, validation, test)

Im Ordner datesets finden Sie mnist.py, der alle Methoden einschließlich next_batch enthält.

1
Sergiu I

Wenn Sie in Ihrem Tensorflow-Sitzungslauf nicht einen Formabweichungsfehler erhalten möchten, verwenden Sie die untenstehende Funktion anstelle der Funktion, die in der ersten Lösung oben angegeben ist ( https://stackoverflow.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
0
Aakash Saxena

Noch eine andere Implementierung:

from typing import Tuple
import numpy as np

class BatchMaker(object):
    def __init__(self, feat: np.array, lab: np.array) -> None:
        if len(feat) != len(lab):
            raise ValueError("Expected feat and lab to have the same number of samples")
        self.feat = feat
        self.lab = lab
        self.indexes = np.arange(len(feat))
        np.random.shuffle(self.indexes)
        self.pos = 0

    # "BatchMaker, BatchMaker, make me a batch..."
    def next_batch(self, batch_size: int) -> Tuple[np.array, np.array]:
        if self.pos + batch_size > len(self.feat):
            np.random.shuffle(self.indexes)
            self.pos = 0
        batch_indexes = self.indexes[self.pos: self.pos + batch_size]
        self.pos += batch_size
        return self.feat[batch_indexes], self.lab[batch_indexes]
0
Mike Gashler