Dela via

Klona funktion

  • Artikel

Kopierar en del av en modells nätverk till en BrainScript-funktion.

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

Parametrar

  • inputNodes är en matris med 1 eller flera indata. Den visar noderna i det ursprungliga nätverket som är indata för den funktion som ska extraheras. När du anropar den resulterande BrainScript-funktionen ersätts den klonade funktionens parametrar med dessa noder.
  • outputNodes är antingen en enskild utdatanod eller en post med flera utdatanoder. Dessa anger vilka noder i det ursprungliga nätverket som är utdata från den klonade funktionen. Den resulterande BrainScript-funktionen returnerar dessa.
  • parameters avgör hur inlärbara parametrar i det klonade avsnittet ska behandlas. Följande värden förstås:
    • "learnable": Varje lärbar parameter i den klonade funktionen får en egen kopia, som hädanefter uppdateras genom träning som vilken annan parameter som helst. Det här är standardinställningen.
    • "constant": Learnable-parametrar kopieras, men fryss sedan. Den klonade funktionen får inga uppdateringar under efterföljande träning, t.ex. om du vill använda en funktionsextraktor som tränats på en stor standardträningsuppsättning i en efterföljande träning på en mindre anpassad uppsättning.
    • "shared": De ursprungliga inlärbara parametrarna fortsätter att användas på ett delat sätt. De kommer att uppdateras under efterföljande träning från både den ursprungliga användningen och den klonade användningen. Om funktionen BrainScript som returneras av CloneFunction() anropas flera gånger delar alla kloner parametrar.

Returvärde

BrainScript-funktion som tar så många indataargument som inputNodes, och returnerar antingen en skalär om outputNodes är en skalär eller en post om outputNodes är en post, med matchande namn.

Description

CloneFunction() är en funktion som används för att redigera och skapa modeller. Den kopierar en del av en modells nätverk till en BrainScript-funktion, så att den här delen av nätverket kan återanvändas. Resultatet är en BrainScript-funktion som kan användas som om den här delen av nätverket hade definierats i en vanlig BrainScript-funktion.

Det ursprungliga nätverket kan vara ett separat nätverk. På så sätt kan du importera (en del av) ett externt nätverk som har tränats på olika data. CloneFunction() tillåter att modellparametrarna för klonen låses. Detta gör att ett externt nätverk kan användas som en fast funktionsextraktor eller fungera som en regularizer i en anpassningsinställning.

Det ursprungliga nätverket kan också vara ett avsnitt av det som definieras för närvarande, och klonen kan dela sina parametrar med originalet. Detta möjliggör flera identiska sökvägar via nätverket som körs på olika data, till exempel för installationer som symmetriskt jämför likheten mellan två indata, där de funktionsextrakterande lagren delas (och lärs gemensamt) för båda indata. Detta fungerar dock inte för närvarande om det ursprungliga nätverksavsnittet innehåller en återkommande loop.

Avsnittet som ska kopieras definieras av dess indata- och utdatanoder. Imagine ett nätverksdiagram där en linje ritas runt underavsnittet som ska klonas. Det här avsnittet som anges av raden anges sedan genom att skicka alla anslutningar som korsar linjen för att ange det markerade området som parameter och inputNodes allt som går ut som outputNodes. CloneFunction() extraherar det här avsnittet till en BrainScript-funktion med ett antal parametrar som är lika med antalet inputNodes, och utdata är antingen en enskild nod eller en ordlista med noder.

Det är också möjligt att beteckna inlärbara parametrar som inputNodes. I det här fallet kan du ersätta nya parametrar som argument till den BrainScript-funktion som CloneFunction() skapar. Gör detta om du vill kopiera en funktion men lär dig parametrarna från grunden. I det här fallet är det också möjligt att ändra dimensioner.

Exempel på användningsfall:

  • anpassning (KL): en låst skrivskyddad kopia av startmodellen används som KL-regularizer
  • anpassning (FDLR): en inmatad indatatransformering tränas medan nätverket är fast
  • bild: lägre lager i ImageNet-nätverk fungerar som oföränderliga funktionsextraktorer för en annan bilduppgift
  • DSSM: tillämpa samma nätverksunderavsnitt på två indata

Problem med nodnamn med .[ och ]

Om du vill referera till en nod i ett nätverk som innehåller . eller [], ersätter du dessa tecken med _. T.ex. om network innehåller en nod med namnet result.z, network.result.z kommer att misslyckas. Säg network.result_zi stället .

Implementeringsanteckning

CloneFunction() skapar inte BrainScript-kod under huven. I stället skapas ett C++-objekt som fungerar som en BrainScript-funktion. CloneFunction() själva klonar inte heller det ursprungliga nätverket. Den innehåller bara en referens. Den faktiska kloningen sker när funktionen som CloneFunction() returnerar anropas.

Exempel

Grundläggande användning:

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

Exempel med flera indata- och utdatanoder:

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

Ett specifikt exempel: Anpassa ett nätverk när du använder det ursprungliga nätverket som en regularizer (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)