La journée communautaire ML est le 9 novembre ! Rejoignez - nous pour les mises à jour de tensorflow, JAX et plus En savoir plus

Diviser et trancher

Tous les ensembles de données TFDS exposent diverses divisions de données (par exemple , 'train' , 'test' ) qui peut être exploré dans le catalogue .

En plus des fractionnements "officiels" de l'ensemble de données, TFDS permet de sélectionner des tranches de fractionnement(s) et diverses combinaisons.

API de découpage

Instructions tranchage sont spécifiées dans tfds.load ou tfds.DatasetBuilder.as_dataset à travers la split= kwarg.

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

La division peut être :

  • Fendu plaine ( 'train' , 'test' ): Tous les exemples dans la division sélectionnée.
  • Tranches: tranches ont la même sémantique que la notation tranche de python . Les tranches peuvent être :
    • Absolu ( 'train[123:450]' , train[:4000] ): (voir la note ci - dessous pour mise en garde sur l' ordre de lecture)
    • Pour cent ( 'train[:75%]' , 'train[25%:75%]' le 'train[25%:75%]' ): Diviser les données complètes en 100 tranches égales. Si les données ne sont pas divisibles par 100, un pourcentage peut contenir des exemples supplémentaires.
    • Shard ( train[:4shard] , le train[4shard] ): Sélectionnez tous les exemples dans le tesson demandé. (voir info.splits['train'].num_shards pour obtenir le nombre de tessons de la scission)
  • Union des scissions ( 'train+test' , 'train[:25%]+test' ): Splits sera entrecroisées.
  • Ensemble complet de données ( 'all' ): 'all' est un nom de groupe , spécial correspondant à l'union de toutes les divisions (équivalent à 'train+test+...' ).
  • Liste des scissions ( ['train', 'test'] ): Multiple tf.data.Dataset sont retournés séparément:
# Returns both train and test split separately
train_ds, test_ds = tfds.load('mnist', split=['train', 'test[50%]'])

tfds.even_splits et formation multi-hôte

tfds.even_splits génère une liste des sous-divisions ne se chevauchant pas de même taille.

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

Cela peut être particulièrement utile lors de la formation dans un environnement distribué, où chaque hôte doit recevoir une tranche des données d'origine. Voici un exemple avec jax :

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

tfds.even_splits accepte sur une valeur de division en entrée (par exemple , 'train[75%:]+test' )

Découpage et métadonnées

Il est possible d'obtenir des informations supplémentaires sur les groupes / subsplits ( num_examples , file_instructions , ...) en utilisant l' information de jeu de données :

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

Validation croisée

Exemples de validation croisée 10 fois à l'aide de l'API de chaîne :

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

Les ensembles de données de validation sont chacun va être de 10%: [0%:10%] , [10%:20%] , ..., [90%:100%] . Et les ensembles de données d'entraînement sont chacun va être de 90% complémentaire: [10%:100%] (pour un ensemble de validation correspondant de [0%:10%] ), '[0%: 10%]

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

tfds.core.ReadInstruction et l' arrondissement

Plutôt que str , il est possible de passer divise comme tfds.core.ReadInstruction :

Par exemple, split = 'train[50%:75%] + test' le split = 'train[50%:75%] + test' équivaut à:

split = (
    tfds.core.ReadInstruction(
        'train',
        from_=50,
        to=75,
        unit='%',
    )

    + tfds.core.ReadInstruction('test')
)
ds = tfds.load('my_dataset', split=split)

unit peut être:

  • abs : découpage absolu
  • % : Pourcentage de découpage en tranches
  • shard : découpage en tranches Shard

tfds.ReadInstruction a également un argument d'arrondi. Si le nombre d'exemple dans l'ensemble de données ne sont pas uniformément par diviser 100 :

  • rounding='closest' la rounding='closest' (par défaut): Les exemples restants sont répartis entre le pour cent, de sorte que certains pour cent peut contenir d' autres exemples.
  • rounding='pct1_dropremainder' : Les autres exemples sont supprimés, mais cette garantie tout pour cent contiennent le même nombre d'exemples précis (par exemple: len(5%) == 5 * len(1%) ).

Reproductibilité & déterminisme

Lors de la génération, pour une version de jeu de données donnée, TFDS garantit que les exemples sont mélangés de manière déterministe sur le disque. Donc, générer l'ensemble de données deux fois (sur 2 ordinateurs différents) ne changera pas l'ordre des exemples.

De même, l'API subsplit sélectionnera toujours le même set d'exemples, quelle que soit la plate - forme, l' architecture, etc. Cette moyenne set('train[:20%]') == set('train[:10%]') + set('train[10%:20%]') .

Cependant, l'ordre dans lequel on lit par exemple peut - être pas déterministe. Cela dépend d'autres paramètres (par exemple , si shuffle_files=True ).