BrainScript CNTK Lettore formato testo

Questa pagina documenta CNTKTextFormatReader dal punto di vista di BrainScript, ma gli utenti Python possono imparare leggendo anche questo documento- i concetti, i parametri e i modelli sono tutti uguali.

CNTKTextFormatReader (in seguito semplicemente lettore CTF) è progettato per usare i dati di testo di input formattati in base alla specifica seguente. Supporta le funzionalità principali seguenti:

• Più flussi di input (input) per file
• Input sia sparse che densi
• Sequenze di lunghezza variabile

CNTK formato testo (CTF)

Ogni riga nel file di input contiene un esempio per uno o più input. Poiché (in modo esplicito o implicito) ogni riga è associata anche a una sequenza, definisce una o più <sequenze, input, relazioni di esempio> . Ogni riga di input deve essere formattata come segue:

[Sequence_Id](Sample or Comment)+

dove

Sample=|Input_Name (Value )*

Comment=|# some content

• Ogni riga inizia con un ID sequenza e contiene uno o più esempi (in altre parole, ogni riga è una raccolta non ordinata di campioni).
• Id sequenza è un numero. Può essere omesso, in questo caso il numero di riga verrà usato come ID sequenza.
• Ogni esempio è effettivamente una coppia chiave-valore costituita da un nome di input e dal vettore di valore corrispondente (il mapping alle dimensioni superiori viene eseguito come parte della rete stessa).
• Ogni esempio inizia con un simbolo di pipe () seguito dal nome di input (|senza spazi), seguito da un delimitatore di spazi vuoti e quindi da un elenco di valori.
• Ogni valore è un numero o un numero con prefisso indice per gli input sparse.
• Sia le schede che gli spazi possono essere usati in modo intercambiabile come delimitatori.
• Un commento inizia con una pipe immediatamente seguita da un simbolo hash: |#, quindi seguito dal contenuto effettivo (corpo) del commento. Il corpo può contenere tutti i caratteri, tuttavia un simbolo di pipe all'interno del corpo deve essere escape aggiungendo il simbolo hash a esso (vedere l'esempio seguente). Il corpo di un commento continua fino alla fine della riga o alla successiva pipe senza escape, che viene prima.

Esempio semplice

Questo esempio si basa su un set minimo di parametri e opzioni di formato.

Per usare il lettore CTF impostato su readerTypeCNTKTextFormatReader nella sezione lettore della configurazione di CNTK:

...
reader = [
    readerType = "CNTKTextFormatReader"
    file = "c:\mydata\SampleInput.txt" # See the second example for Linux path example

    # IMPORTANT!
    # All inputs are grouped within "input" sub-section.
    input = [
        A = [
            dim = 5
            format = "dense"
        ]
        B = [
            dim = 1000000
            format = "sparse"
        ]
        C = [
            dim = 1
            format = "dense"
        ]
    ]
]
# the rest of the cntk config ...

Questo frammento e altri esempi NDL in questo documento presentano solo reader la sezione, omettendo il resto della configurazione CNTK; vedere la fine di questa pagina per i puntatori a un set di reti di esempio complete e i set di dati corrispondenti)

Il lettore CTF richiede il set di parametri seguente:

• file - percorso del file con il set di dati.
• input- sezione secondaria che definisce gli input identificati dai nomi di input (ABe C nell'esempio precedente). All'interno di ogni input devono essere specificati i parametri necessari seguenti:
  • format - specifica il tipo di input. Deve essere dense o sparse
  • dim - specifica la dimensione del vettore di valore di input (per l'input denso questo corrisponde direttamente al numero di valori in ogni esempio, per sparse questo rappresenta il limite superiore nell'intervallo di valori di indice possibili).

I dati di input corrispondenti alla configurazione del lettore precedente dovrebbero essere simili al seguente:

|B 100:3 123:4 |C 8 |A 0 1 2 3 4 |# a CTF comment
|# another comment |A 0 1.1 22 0.3 54 |C 123917 |B 1134:1.911 13331:0.014
|C -0.001 |# a comment with an escaped pipe: '|#' |A 3.9 1.11 121.2 99.13 0.04 |B 999:0.001 918918:-9.19

Si noti quanto segue sul formato di input:

• |Input_Name identifica l'inizio di ogni esempio di input. Questo elemento è obbligatorio e viene seguito dal vettore del valore corrispondente.
• Il vettore denso è solo un elenco di valori a virgola mobile; il vettore sparse è un elenco di index:value tuple.
• Sia le schede che gli spazi sono consentiti come delimitatori di valore (all'interno di vettori di input) e delimitatori di input (tra input).
• Ogni riga separata costituisce una "sequenza" di lunghezza 1 ("Real" sequenze di lunghezza variabile sono descritte nell'esempio esteso riportato di seguito).
• Ogni identificatore di input può essere visualizzato una sola volta su una singola riga (che traduce in un esempio per ogni requisito di input per ogni requisito di riga ).
• L'ordine degli esempi di input all'interno di una riga non è importante (concettualmente, ogni riga è una raccolta non ordinata di coppie chiave-valore)
• Ogni riga ben formata deve terminare con simboli "Feed linea" \n o "Ritorno a capo, Feed linea". \r\n

Esempio esteso

In questo esempio sono disponibili tutti i possibili parametri di configurazione e vengono visualizzate varie opzioni di formato di input. Per la descrizione completa dei parametri di configurazione usati in questo esempio, vedere le tabelle seguenti .

...
precision="double"

reader = [
    readerType = "CNTKTextFormatReader"
    file = "/home/mydata/SampleInput.txt" # See the first example for Windows style path example
    randomize = true
    randomizationWindow = 30
    skipSequenceIds = false
    maxErrors = 100
    traceLevel = 2

    chunkSizeInBytes = 1024

    keepDataInMemory = true
    frameMode = false

    input = [
        Some_very_long_input_name = [
            alias = "a"
            dim = 3
            format = "dense"
        ]
        Some_other_also_very_long_input_name = [
            alias = "b"
            dim = 2
            format = "dense"
        ]
    ]
]
# the rest of the cntk config ...

Con un lettore composito, si desidera quanto segue:

reader = {
        verbosity = 0 ;
        randomize = true;
        randomizationWindow=30
        deserializers = ({
            type = "CNTKTextFormatDeserializer" ; module = "CNTKTextFormatReader"
            file = "/home/mydata/SampleInput.txt" # See the first example for Windows style path example
            maxErrors = 100
            skipSequenceIds = false
            traceLevel = 2
            input = {
                qu1fea = {alias = "qui"; dim = 95589; format = "sparse"}
                qu2fea = {alias = "quj"; dim = 95589; format = "sparse"}
                pairweight = {alias = "wij"; dim = 1; format = "dense"}
            }
        })
    }

Il file di input corrispondente può quindi essere simile al seguente:

100 |a 1 2 3 |b 100 200
100 |a 4 5 6 |b 101 201
100 |b 102983 14532 |a 7 8 9
100 |a 7 8 9
200 |b 300 400 |a 10 20 30
333 |b 500 100
333 |b 600 -900
400 |a 1 2 3 |b 100 200
|a 4 5 6 |b 101 201
|a 4 5 6 |b 101 201
500 |a 1 2 3 |b 100 200

Tutte le opzioni descritte nell'esempio precedente, si applicano ancora qui. Oltre a questo, sono state introdotte due funzionalità aggiuntive:

Alias del nome di input

I nomi di input possono essere arbitrari e quindi ripetuti in tutto il file di input potrebbero non essere efficienti nello spazio. Per attenuare questo problema, il set di dati può usare "alias" anziché nomi di input completi. Gli alias devono quindi essere specificati all'interno di ogni sottosezione di input. Nell'esempio, il set di dati usa gli alias a e , che vengono mappati rispettivamente a "Some_very_long_input_name" e b"Some_other_also_very_long_input_name" nella sezione di configurazione del lettore.

ID sequenza

Come già accennato, ogni riga separata nel file di input rappresenta una sequenza contenente un singolo esempio per ogni input. Tuttavia, se una riga è preceduta da un numero non negativo, il numero viene usato come ID sequenza corrispondente. Tutte le righe successive che condividono lo stesso ID sequenza vengono unite insieme per diventare parte della stessa sequenza. Pertanto, ripetere lo stesso prefisso numerico per le righe N consente di creare una sequenza di più campioni, con ogni input contenente tra 1 e N esempi. L'omettezione del prefisso della sequenza sulla seconda e le righe seguenti hanno lo stesso effetto. Pertanto, il set di dati di esempio precedente definisce cinque sequenze con IDs 100, , 400200333e .500

L'impostazione skipSequenceIds del parametro nella sezione lettore su true, impone al lettore di ignorare tutti gli ID sequenza espliciti nel set di dati e trattare righe separate come singole sequenze. Inoltre, omettendo l'ID sequenza nella prima riga del set di dati ha lo stesso effetto , tutte le sequenze successive vengono ignorate, le righe considerate come singole sequenze, come in questo esempio:

|a 1 2 3 |b 100 200
100 |a 4 5 6 |b 101 201
200 |b 102983 14532 |a 7 8 9

Alcuni aspetti finali da considerare quando si usano sequenze:

• Gli ID sequenza devono essere univoci.
• I prefissi ID possono essere ripetuti solo per le righe consecutive.
• La lunghezza della sequenza in righe ,ovvero il numero di righe che condividono lo stesso prefisso ID, non deve superare la lunghezza massima di input nei campioni (il numero di campioni in un input) in questa sequenza.

Ad esempio, i set di dati seguenti non sono validi:

100 |a 1 2 3 |b 100 200
200 |a 4 5 6 |b 101 201
100 |b 102983 14532 |a 7 8 9

123 |a 1 2 3 |b 100 200
456 |a 4 5 6
456 |b 101 201

Alcuni esempi di Real-World

• Classificazione: ogni riga contiene un esempio, costituito da un'etichetta e funzionalità. Nessun ID sequenza necessario, poiché ogni riga è la propria "sequenza" di lunghezza 1.

|class 23:1 |features 2 3 4 5 6
|class 13:1 |features 1 2 0 2 3
...

• DSSM: ogni riga contiene una coppia di documenti di destinazione di origine, espressa tramite un contenitore di parole, codificate come vettori sparse.

|src 12:1 23:1 345:2 45001:1    |tgt 233:1 766:2 234:1
|src 123:1 56:1 10324:1 18001:3 |tgt 233:1 2344:2 8889:1 2234:1 253434:1

• Tag di parte del riconoscimento vocale: sequenze che esegue il mapping di ogni elemento a un'etichetta corrispondente. Le sequenze sono allineate verticalmente (una parola + tag per riga).

0 |word 234:1 |tag 12:1
0 |word 123:1 |tag 10:1
0 |word 123:1 |tag 13:1
1 |word 234:1 |tag 12:1
1 |word 123:1 |tag 10:1
...

• Classificazione della sequenza: sequenze mappate a una singola etichetta. Le sequenze sono allineate verticalmente; L'etichetta "class" può verificarsi in qualsiasi riga con lo stesso sequenceId.

0 |word 234:1 |class 3:1
0 |word 123:1
0 |word 890:1
1 |word 11:1 |class 2:1
1 |word 344:1

• Sequenza in sequenza: eseguire il mapping di una sequenza di origine a una sequenza di destinazione. Le due sequenze sono allineate verticalmente e, nel caso più semplice, appena stampato dopo un altro. Vengono aggiunti con lo stesso "ID sequenza" complessivo (che diventa quindi un "ID unità di lavoro" in questo caso).

0 |sourceWord 234:1  |targetWord 344:1
0 |sourceWord 123:1  |targetWord 456:1
0 |sourceWord 123:1  |targetWord 2222:1
0 |sourceWord 11:1
1 |sourceWord 123:1
...

• Learning a Classificazione: una "sequenza" rappresenta una query, ogni esempio di un documento con una classificazione etichettata a mano. In questo caso la "sequenza" è solo un multiset che (nel contesto di una funzione di perdita di apprendimento a classificazione) non ha un ordinamento.

0 |rating 4 |features 23 35 0 0 0 21 2345 0 0 0 0 0
0 |rating 2 |features 0 123 0 22 44 44 290 22 22 22 33 0
0 |rating 1 |features 0 0 0 0 0 0 1 0 0 0 0 0
1 |rating 1 |features 34 56 0 0 0 45 1312 0 0 0 0 0
1 |rating 0 |features 45 45 0 0 0 12 335 0 0 0 0 0
2 |rating 0 |features 0 0 0 0 0 0 22 0 0 0 0 0
...

Parametri di configurazione

reader Sezione

Memorizzazione nella cache degli indici

La memorizzazione nella cache degli indici consente di ridurre in modo significativo (con un fattore di 2-3 volte) i tempi di avvio, soprattutto quando si utilizzano file di input di grandi dimensioni. L'impostazione del cacheIndex flag su true segnalerà al lettore di scrivere i metadati di indicizzazione su disco (stessa directory del file di input) se il file della cache non è disponibile o se è obsoleto (precedente al file di input). La scrittura è un'operazione ottimale e viene eseguita su un thread separato per non influire sulle prestazioni del lettore. Se il file della cache è presente ed è aggiornato, il lettore non eseguirà più lo skim del file di input per compilare l'indice, ma caricherà l'indice dal file della cache. Si noti che alcuni parametri di configurazione del lettore hanno un impatto diretto sull'indicizzazione (ad esempio, valori diversi di frameMode potrebbero causare indici con un numero diverso di sequenze). Per questo motivo, un file della cache potrebbe essere ignorato da un lettore con una configurazione diversa da quella che ha prodotto la cache. Per visualizzare il vantaggio completo della memorizzazione nella cache, la configurazione non deve essere modificata nelle riesecuzioni successive.

input sezione secondaria

input combina un numero di singoli input, ognuno con una sottosezione di configurazione con etichetta appropriata. Tutti i parametri descritti di seguito sono specifici di una sottosezione Nome input associata a un determinato input.

Sono disponibili definizioni di rete complete e gli esempi di set di dati corrispondenti nel repository CNTK. È disponibile anche un test end-to-end che usa il lettore CNTKTextFormat.