Grazie per esserti sintonizzato su Google I/O. Visualizza tutte le sessioni su richiesta Guarda su richiesta

Spacca e affetta

Tutti i set di dati TFDS espongono varie suddivisioni di dati (ad es 'train' , 'test' ) che possono essere esplorate nel catalogo .

Oltre alle suddivisioni "ufficiali" del set di dati, TFDS consente di selezionare fette di suddivisione e varie combinazioni.

API per affettare

Le istruzioni di slicing sono specificate in tfds.load o tfds.DatasetBuilder.as_dataset tramite split= kwarg.

ds = tfds.load('my_dataset', split='train[:75%]')

builder = tfds.builder('my_dataset')
ds = builder.as_dataset(split='test+train[:75%]')

La divisione può essere:

  • Divisione semplice ( 'train' , 'test' ): tutti gli esempi all'interno della divisione selezionata.
  • Fette : le fette hanno la stessa semantica della notazione della fetta di Python . Le fette possono essere:
    • Absolute ( 'train[123:450]' , train[:4000] ): (vedi nota sotto per avvertimenti sull'ordine di lettura)
    • Percentuale ( 'train[:75%]' , 'train[25%:75%]' ): divide i dati completi in 100 sezioni pari. Se i dati non sono divisibili per 100, una certa percentuale potrebbe contenere ulteriori esempi.
    • Shard ( train[:4shard] , train[4shard] ): seleziona tutti gli esempi nello shard richiesto. (vedi info.splits['train'].num_shards per ottenere il numero di frammenti della divisione)
  • Unione delle divisioni ( 'train+test' , 'train[:25%]+test' ): le divisioni saranno intercalate insieme.
  • Set di dati completo ( 'all' ): 'all' è un nome di divisione speciale corrispondente all'unione di tutte le divisioni (equivalente a 'train+test+...' ).
  • Elenco di suddivisioni ( ['train', 'test'] ): più tf.data.Dataset vengono restituiti separatamente:
# Returns both train and test split separately
train_ds, test_ds = tfds.load('mnist', split=['train', 'test[:50%]'])

tfds.even_splits e formazione multi-host

tfds.even_splits genera un elenco di sub-split non sovrapposti della stessa dimensione.

# Divide the dataset into 3 even parts, each containing 1/3 of the data
split0, split1, split2 = tfds.even_splits('train', n=3)

ds = tfds.load('my_dataset', split=split2)

Ciò può essere particolarmente utile durante l'addestramento in un ambiente distribuito, in cui ogni host dovrebbe ricevere una porzione dei dati originali.

Con Jax , questo può essere ulteriormente semplificato usando tfds.split_for_jax_process :

split = tfds.split_for_jax_process('train', drop_remainder=True)
ds = tfds.load('my_dataset', split=split)

tfds.split_for_jax_process è un semplice alias per:

# The current `process_index` loads only `1 / process_count` of the data.
splits = tfds.even_splits('train', n=jax.process_count(), drop_remainder=True)
split = splits[jax.process_index()]

tfds.even_splits , tfds.split_for_jax_process accetta qualsiasi valore diviso come input (ad esempio 'train[75%:]+test' )

Slicing e metadati

È possibile ottenere informazioni aggiuntive sugli split/subsplit ( num_examples , file_instructions ,...) utilizzando le informazioni sul set di dati:

builder = tfds.builder('my_dataset')
builder.info.splits['train'].num_examples  # 10_000
builder.info.splits['train[:75%]'].num_examples  # 7_500 (also works with slices)
builder.info.splits.keys()  # ['train', 'test']

Convalida incrociata

Esempi di convalida incrociata 10 volte utilizzando l'API di stringa:

vals_ds = tfds.load('mnist', split=[
    f'train[{k}%:{k+10}%]' for k in range(0, 100, 10)
])
trains_ds = tfds.load('mnist', split=[
    f'train[:{k}%]+train[{k+10}%:]' for k in range(0, 100, 10)
])

I set di dati di convalida saranno ciascuno del 10%: [0%:10%] , [10%:20%] , ..., [90%:100%] . E i set di dati di addestramento saranno ciascuno il 90% complementare: [10%:100%] (per un set di convalida corrispondente di [0%:10%] ), `[0%:10%]

  • [20%:100%] (for a validation set of [10%:20%]`),...

tfds.core.ReadInstruction e arrotondamento

Piuttosto che str , è possibile passare le divisioni come tfds.core.ReadInstruction :

Ad esempio, split = 'train[50%:75%] + test' equivale a:

split = (
    tfds.core.ReadInstruction(
        'train',
        from_=50,
        to=75,
        unit='%',
    )
    + tfds.core.ReadInstruction('test')
)
ds = tfds.load('my_dataset', split=split)

l' unit può essere:

  • abs : Affettatura assoluta
  • % : Affettatura percentuale
  • shard : Affettatura del frammento

tfds.ReadInstruction ha anche un argomento di arrotondamento. Se il numero di esempi nel set di dati non è diviso equamente per 100 :

  • rounding='closest' (predefinito): gli esempi rimanenti sono distribuiti tra le percentuali, quindi alcune percentuali potrebbero contenere esempi aggiuntivi.
  • rounding='pct1_dropremainder' : gli esempi rimanenti vengono eliminati, ma questo garantisce che tutte le percentuali contengano esattamente lo stesso numero di esempi (ad esempio: len(5%) == 5 * len(1%) ).

Riproducibilità e determinismo

Durante la generazione, per una determinata versione del set di dati, TFDS garantisce che gli esempi vengano mischiati deterministicamente su disco. Pertanto, la generazione del set di dati due volte (in 2 computer diversi) non cambierà l'ordine dell'esempio.

Allo stesso modo, l'API subsplit selezionerà sempre lo stesso set di esempi, indipendentemente dalla piattaforma, dall'architettura, ecc. Ciò significa set('train[:20%]') == set('train[:10%]') + set('train[10%:20%]') .

Tuttavia, l'ordine in cui vengono letti gli esempi potrebbe non essere deterministico. Questo dipende da altri parametri (ad esempio se shuffle_files=True ).