Funzione Clone

Copia una parte della rete di un modello in una funzione BrainScript.

BS.Network.CloneFunction (inputNodes, outputNodes,
                          parameters="learnable" /*|"constant"|"shared"*/)

Parametri

• inputNodes è una matrice di 1 o più input. Elenca i nodi della rete di origine che sono gli input della funzione da estrarre. Quando si chiama la funzione BrainScript risultante, i parametri della funzione clonata vengono sostituiti con questi nodi.
• outputNodes è un singolo nodo di output o un record di più nodi di output. Questi indicano quali nodi nella rete di origine sono l'output della funzione clonata. La funzione BrainScript risultante restituirà questi valori.
• parameters determina la modalità di trattamento dei parametri appresi all'interno della sezione clonata. Vengono riconosciuti i valori seguenti:
  • "learnable": ogni parametro imparabile nella funzione clonata otterrà la propria copia, che viene quindi aggiornata eseguendo il training come qualsiasi altro parametro. Si tratta dell'impostazione predefinita.
  • "constant": i parametri learnable vengono copiati, ma quindi bloccati. La funzione clonata non riceverà aggiornamenti durante il training successivo, ad esempio se si vuole usare un estrattore di funzionalità sottoposto a training su un set di training standard di grandi dimensioni in un training successivo su un set personalizzato più piccolo.
  • "shared": i parametri appresi originali continueranno a essere usati in modo condiviso. Verranno aggiornati durante il training successivo sia dall'uso originale che dall'uso clonato. Se la funzione BrainScript restituita da CloneFunction() viene richiamata più volte, tutti i cloni condivideranno i parametri.

Valore restituito

La funzione BrainScript accetta tutti gli argomenti di input inputNodese restituisce un valore scalare se outputNodes è scalare o un record se outputNodes è un record, con nomi corrispondenti.

Descrizione

è una funzione da usare per la modifica e la creazione di modelli. Copia una parte della rete di un modello in una funzione BrainScript, in modo che questa parte della rete possa essere riutilizzata. Il risultato è una funzione BrainScript che può essere usata come se questa sezione della rete fosse stata definita all'interno di una normale funzione BrainScript.

La rete di origine può essere una rete separata. In questo modo è possibile importare (parte di) una rete esterna sottoposta a training su dati diversi. CloneFunction() consente di bloccare i parametri del modello del clone. Ciò consente l'uso di una rete esterna come estrattore di funzionalità fisse o di fungere da regolarizzatore in un'impostazione di adattamento.

La rete di origine può anche essere una sezione di quella attualmente definita e il clone può condividere i parametri con l'originale. Ciò consente più percorsi identici attraverso la rete che opera su dati diversi, ad esempio per le configurazioni che confrontano simmetricamente la somiglianza di due input, in cui i livelli di estrazione delle funzionalità vengono condivisi (e appresi congiuntamente) per entrambi gli input. Questo attualmente non funziona, tuttavia, se la sezione di rete di origine contiene un ciclo ricorrente.

La sezione da copiare viene definita dai nodi di input e output. Si immagini un tracciato di rete in cui viene tracciata una linea intorno alla sottosezione da clonare. Questa sezione indicata dalla riga verrà quindi specificata passando tutte le connessioni che intersecano la riga per immettere l'area contrassegnata come parametro inputNodes e tutte le connessioni che escono come outputNodes. CloneFunction() estrae questa sezione in una funzione BrainScript con un numero di parametri uguale al numero di inputNodese l'output è un singolo nodo o un dizionario di nodi.

È anche possibile indicare parametri appresi come inputNodes. In questo caso, è possibile sostituire i nuovi parametri come argomenti con la funzione BrainScript creata CloneFunction(). Eseguire questa operazione se si vuole copiare una funzione ma apprendere i parametri da zero. In questo caso, è anche possibile modificare le dimensioni.

Casi d'uso di esempio:

• adattamento (KL): una copia di sola lettura bloccata del modello iniziale viene usata come regolarizzatore KL
• adattamento (FDLR): viene eseguito il training di una trasformazione di input inserita mentre la rete è fissa
• immagine: i livelli inferiori delle reti ImageNet fungono da estrattori di funzionalità non modificabili per un'altra attività immagine
• DSSM: applicazione della stessa sottosezione di rete a due input

Problemi con i nomi dei nodi con .[ e ]

Per fare riferimento a un nodo in una rete contenente . o [ o ], sostituire tali caratteri _. Ad esempio, se network contiene un nodo denominato result.z, network.result.z avrà esito negativo; pronunciare invece network.result_z.

Nota sull'implementazione

CloneFunction() non crea effettivamente codice BrainScript sotto le quinte. Crea invece un oggetto C++ che si comporta come una funzione BrainScript. CloneFunction() stessa non clona anche la rete di origine. Contiene solo un riferimento. La clonazione effettiva si verifica quando viene chiamata la funzione che CloneFunction() restituisce.

Esempi

Utilizzo di base:

# create a BS function by copying a piece of an existing network loaded from disk
network = BS.Network.Load ("some.dnn")
net = BS.Network.CloneFunction (network.features, network.logP)
# apply the copy to a new input
out = net (myFeatures)
# This will create a copy of the subsection from network.features to network.logP
# where all links to network.features get replaced by links to myFeatures.

Esempio con più nodi di input e output:

# This specific example passes two input nodes --> the resulting BS function will have 2 inputs;
# and it passes a record of output nodes --> the BS function will return a record with the same member names
network = BS.Network.Load ("some.dnn")
net = BS.Network.CloneFunction ((network.features:network.labels), [ ce = network.ce ; errs = network.errs ])
# 'net' is now a BrainScript function with this signature:
#   CloneFunction (input1, input2) --> [ ce = ... ; errs = ... ]

# now create a network from the BS function
myFeatures = Input (13)
myLabels = Input (42)
out = net (myFeatures, myLabels) # e.g. myFeatures substitutes the original 'features' node
criterionNodes = (out.ce)        # and the return value is a record with members 'ce' and 'errs'
evaluationNodes = (out.errs)

Esempio specifico: adattamento di una rete, mentre si usa la rete originale come regolarizzatore (KLD):

# load network
network = BS.Network.Load ("some.dnn")
# create a trainable clone and a read-only reference clone
adaptNet = BS.Network.CloneFunction (network.features, [ z = network.z ], parameters="learnable")
refNet   = BS.Network.CloneFunction (network.features, [ z = network.z ], parameters="constant")

# create the main network
features = Input (42)
labels = Input (9000)
z    = adaptNet (features).z
zRef = refNet   (features).z
# training criterion
# In KL adaptation, labels are a linear interpolation of the one-hot targets
# and the posteriors produced by the reference network.
refWeight = 0.9
kldLabels = labels * (1-refWeight) + Softmax (zRef) * refWeight  # interpolate with ref output
ce = CrossEntropyWithSoftmax (kldLabels, z) # the CE criterion is taken against these interpolated soft labels
errs = ErrorPrediction (labels, z)          # errors are of course still counted against the actual labels 
criterionNodes = (ce)
evaluationNodes = (errs)