Wie kann man auf die Darstellung versteckter Layer in CNTK 2.2 zugreifen?

Question

Angenommen, ich habe ein einfaches Modell.

def create_model(out_classes): 
    f1 = Dense(16, activation=C.relu,bias=True,init_bias=0,name='FLayer') 
    l1 = Dense(16, activation=C.relu, bias=True, init_bias=0, name='LLayer')(f1) 
    c1 = Dense(out_classes,name='CLayer')(l1) 
    return c1 

model = create_model(nClasses) 
z = model(feature) 

Wie greife ich auf die Darstellung des FLAYER oder LLayer während der Prüfung meines ausgebildeten Modell?

Answer 1

Mit Darstellung meinen Sie den Zugriff auf die Funktionen der versteckten Ebenen richtig? Ich habe einen Beispielcode erstellt, um es anzuzeigen. Ich habe zwei Ansätze getestet, der erste Ansatz baut auf dem auf, was Sie getan haben, und der zweite nutzt die funktionale API von CNTK, die ich bevorzuge.

Die einfache Art und Weise Zugriff auf die Funktionen zu erhalten, ist sie zurück:

import cntk 
import numpy as np 


def create_model(output_dimension): 
    l0 = cntk.layers.Dense(shape=1, activation=None, init=1, init_bias=1) 
    l1 = cntk.layers.Dense(shape=output_dimension, activation=None, init=1, init_bias=1)(l0) 
    l2 = cntk.layers.Dense(shape=output_dimension, activation=None, init=1, init_bias=1)(l1) 
    return l0, l1, l2 

input_dim = 1 
output_dim = 1 
l0, l1, l2 = create_model(output_dim) 
input = cntk.input_variable(shape=1) 
layer0 = l0(input) 
layer1 = l1(input) 
layer2 = l2(input) 

print("Non functional API") 
print("output of layer 0: {}".format(layer0.eval({input: np.array([0], dtype=np.float32)}))) 
print("output of layer 1: {}".format(layer1.eval({input: np.array([0], dtype=np.float32)}))) 
print("output of model: {}".format(layer2.eval({input: np.array([0], dtype=np.float32)}))) 

Das obige Modell 1 ein Vektor der Dimension eine Eingabe der Dimension 1 und Ausgang nimmt ich die Gewichte und spannt auch auf 1 in jeder Schicht, so ist es leicht, die Berechnung zu folgen. Die Funktion create_model gibt ein Tupel zurück, das alle Layer enthält, auf die extern zugegriffen werden kann.

Der funktionale API-Ansatz ist meiner Meinung nach besser. Im Folgenden erstelle ich eine Liste mit den verschiedenen Layern und erstelle dann das Modell mit cntk.layers.Sequential. Dann gibt create_model2 ein Tupel zurück, dessen Einträge 1) die Liste mit allen Schichten und 2) das endgültige Modell sind. Dies ist sauberer, wenn Sie mehrere Ebenen haben. Außerdem erhalten Sie dadurch eine bessere Kontrolle darüber, was Sie mit jeder Schicht tun können.

def create_model2(output_dimension): 
    layers = [cntk.layers.Dense(shape=1, activation=None, init=1, init_bias=1), 
       cntk.layers.Dense(shape=output_dimension, activation=None, init=1, init_bias=1), 
       cntk.layers.Dense(shape=output_dimension, activation=None, init=1, init_bias=1)] 
    m = cntk.layers.Sequential(layers) 

    return m, layers 

m, layers = create_model2(output_dim) 
layer0 = layers[0](input) 
layer1 = layers[1](input) 
layer2 = layers[2](input) 
layer01 = cntk.layers.Sequential(layers[0:2])(input) 
layer012 = cntk.layers.Sequential(layers[0:3])(input) 
model = m(input) 

print("Functional API") 
print("output of layer 0: {}".format(layer0.eval({input: np.array([0], dtype=np.float32)}))) 
print("output of layer 1: {}".format(layer1.eval({input: np.array([0], dtype=np.float32)}))) 
print("output of layer 2: {}".format(layer2.eval({input: np.array([0], dtype=np.float32)}))) 
print("output of model: {}".format(model.eval({input: np.array([0], dtype=np.float32)}))) 
print("output of layer 0 and 1: {}".format(layer01.eval({input: np.array([0], dtype=np.float32)}))) 
print("output of layer 0 and 1 and 2: {}".format(layer012.eval({input: np.array([0], dtype=np.float32)})))