Tiefenschätzung mit Keras

Question

Ich versuche ein Convolutional Net zu entwerfen, um die Tiefe von Bildern mit Keras zu schätzen.

Ich habe RGB-Input-Bilder mit der Form von 3x120x160 und haben die Graustufen Output Depth Maps mit der Form von 1x120x160.

Ich habe versucht, eine VGG-ähnliche Architektur zu verwenden, wo die Tiefe jeder Schicht wächst, aber am Ende, wenn ich die letzten Schichten entwerfen will, bleibe ich stecken. Die Verwendung einer Dense-Schicht ist zu teuer und ich habe versucht, Upsampling zu verwenden, was sich als ineffizient erwiesen hat.

Ich möchte DeConvolution2D verwenden, aber ich kann es nicht funktionieren. die einzige Architektur ich am Ende ist so etwas wie dieses:

model = Sequential() 
    model.add(Convolution2D(64, 5, 5, activation='relu', input_shape=(3, 120, 160))) 
    model.add(Convolution2D(64, 5, 5, activation='relu')) 
    model.add(MaxPooling2D()) 
    model.add(Dropout(0.5)) 

    model.add(Convolution2D(128, 3, 3, activation='relu')) 
    model.add(Convolution2D(128, 3, 3, activation='relu')) 
    model.add(MaxPooling2D()) 
    model.add(Dropout(0.5)) 

    model.add(Convolution2D(256, 3, 3, activation='relu')) 
    model.add(Convolution2D(256, 3, 3, activation='relu')) 
    model.add(Dropout(0.5)) 

    model.add(Convolution2D(512, 3, 3, activation='relu')) 
    model.add(Convolution2D(512, 3, 3, activation='relu')) 
    model.add(Dropout(0.5)) 

    model.add(ZeroPadding2D()) 
    model.add(Deconvolution2D(512, 3, 3, (None, 512, 41, 61), subsample=(2, 2), activation='relu')) 
    model.add(Deconvolution2D(512, 3, 3, (None, 512, 123, 183), subsample=(3, 3), activation='relu')) 
    model.add(cropping.Cropping2D(cropping=((1, 2), (11, 12)))) 
    model.add(Convolution2D(1, 1, 1, activation='sigmoid', border_mode='same')) 

Das Modell Zusammenfassung ist wie folgt:

Layer (type)      Output Shape   Param #  Connected to      
==================================================================================================== 
convolution2d_1 (Convolution2D) (None, 64, 116, 156) 4864  convolution2d_input_1[0][0]  
____________________________________________________________________________________________________ 
convolution2d_2 (Convolution2D) (None, 64, 112, 152) 102464  convolution2d_1[0][0]    
____________________________________________________________________________________________________ 
maxpooling2d_1 (MaxPooling2D) (None, 64, 56, 76) 0   convolution2d_2[0][0]    
____________________________________________________________________________________________________ 
dropout_1 (Dropout)    (None, 64, 56, 76) 0   maxpooling2d_1[0][0]    
____________________________________________________________________________________________________ 
convolution2d_3 (Convolution2D) (None, 128, 54, 74) 73856  dropout_1[0][0]     
____________________________________________________________________________________________________ 
convolution2d_4 (Convolution2D) (None, 128, 52, 72) 147584  convolution2d_3[0][0]    
____________________________________________________________________________________________________ 
maxpooling2d_2 (MaxPooling2D) (None, 128, 26, 36) 0   convolution2d_4[0][0]    
____________________________________________________________________________________________________ 
dropout_2 (Dropout)    (None, 128, 26, 36) 0   maxpooling2d_2[0][0]    
____________________________________________________________________________________________________ 
convolution2d_5 (Convolution2D) (None, 256, 24, 34) 295168  dropout_2[0][0]     
____________________________________________________________________________________________________ 
convolution2d_6 (Convolution2D) (None, 256, 22, 32) 590080  convolution2d_5[0][0]    
____________________________________________________________________________________________________ 
dropout_3 (Dropout)    (None, 256, 22, 32) 0   convolution2d_6[0][0]    
____________________________________________________________________________________________________ 
convolution2d_7 (Convolution2D) (None, 512, 20, 30) 1180160  dropout_3[0][0]     
____________________________________________________________________________________________________ 
convolution2d_8 (Convolution2D) (None, 512, 18, 28) 2359808  convolution2d_7[0][0]    
____________________________________________________________________________________________________ 
dropout_4 (Dropout)    (None, 512, 18, 28) 0   convolution2d_8[0][0]    
____________________________________________________________________________________________________ 
zeropadding2d_1 (ZeroPadding2D) (None, 512, 20, 30) 0   dropout_4[0][0]     
____________________________________________________________________________________________________ 
deconvolution2d_1 (Deconvolution2(None, 512, 41, 61) 2359808  zeropadding2d_1[0][0]    
____________________________________________________________________________________________________ 
deconvolution2d_2 (Deconvolution2(None, 512, 123, 183) 2359808  deconvolution2d_1[0][0]   
____________________________________________________________________________________________________ 
cropping2d_1 (Cropping2D)  (None, 512, 120, 160) 0   deconvolution2d_2[0][0]   
____________________________________________________________________________________________________ 
convolution2d_9 (Convolution2D) (None, 1, 120, 160) 513   cropping2d_1[0][0]    
==================================================================================================== 
Total params: 9474113 

Ich konnte die Größe der Deconvolution2D Schichten von 512 als dabei Ergebnisse in Form nicht reduzieren verwandte Fehler und es scheint, dass ich so viele Deconvolution2D-Layer hinzufügen muss wie die Anzahl der Filter in der vorherigen Ebene. Ich musste auch eine letzte Convolution2D-Schicht hinzufügen, um das Netzwerk zu betreiben.

Die obige Architektur lernt aber wirklich langsam und (ich denke) ineffizient. Ich bin sicher, ich mache etwas falsch und das Design sollte nicht so sein. Kannst du mir helfen, ein besseres Netzwerk zu entwickeln?

Ich habe auch versucht, ein Netzwerk als das in this repository erwähnt zu machen, aber es scheint, Keras funktioniert nicht, wie dieses Lasagne Beispiel tut. Ich würde es sehr schätzen, wenn mir jemand zeigen könnte, wie man so etwas in Keras gestaltet. Es ist Architektur ist wie folgt:

Dank

Answer 1

Ich würde vorschlagen, eine U-Net (siehe Abbildung 1). In der ersten Hälfte eines U-Net wird die räumliche Auflösung reduziert, wenn die Anzahl der Kanäle zunimmt (wie VGG, wie Sie erwähnt haben). In der zweiten Hälfte passiert das Gegenteil (Anzahl der Kanäle wird reduziert, Auflösung erhöht sich). "Skip" -Verbindungen zwischen verschiedenen Schichten ermöglichen es dem Netzwerk, hochauflösende Ausgaben effizient zu erzeugen.

Sie sollten in der Lage sein, eine geeignete Keras-Implementierung zu finden (vielleicht).