C++ Rückpropagation auf einem Graphen; heterogene Vektoren?

Question

Ich habe in der Vergangenheit erfolgreich ein paar neuronale Netze geschrieben. Ich habe ein mehrschichtiges Perzeptron mit vollständig verbundenen Schichten (beliebiger Größe und Menge) geschrieben und mit Backprop trainiert. Ich habe ein Faltungsnetz gemacht und seine Gradienten mit handgeschriebener/berechneter Mathematik gefunden. Ich versuche jetzt, allgemeiner zu sein. Ich möchte im Geiste von Theano Backpropagation für jede Computergraphik schreiben.

Betrachten Sie diese Python-Code:

from __future__ import division 
from pylab import * 
class Node(object): 
    def __init__(self): 
     self.children = [] 
     self.parents = [] 
     self.state = [] 
    def forward_prop(self): 
     for child in self.children: 
      child.forward_prop() 


class Static(Node): 
    def __init__(self, *shape): 
     super(Static, self).__init__() 
     state = zeros(shape) 

class MatrixProduct(Node): 
    def __init__(self, w, x): 
     super(MatrixProduct, self).__init__() 
     self.w = w 
     self.x = x 
     self.state = [0]*len(x.state) 

    def forward_prop(self): 
     self.state = self.w.state.dot(self.x.state) 
     for child in self.children: 
      child.forward_prop() 

class Doubler(Node): 
    def __init__(self): 
     super(Doubler, self).__init__() 
    def forward_prop(self): 
     self.state = [s*2 for s in self.state] 
     for child in self.children: 
      child.forward_prop() 


a = Static() 
a.state = array([2,3]) 
w = Static() 
w.state = array([[1,2],[3,4]]) 
x = MatrixProduct(w, a) 
a.children.append(x) 
d = Doubler() 
d.state.append(3) 
x.children.append(d) 
a.forward_prop() 
print a.state 
print d.state 

ich meistens sehen, wie Hafen, das zu C++. Mein Problem ist, dass ich nicht herausfinden kann, wie die Weiterleitung von Kindern in C++ funktioniert. In Python ist das ganz einfach, da children eine Liste potenziell heterogener Typen ist, die jeweils ihr eigenes forward_propagate-Verhalten haben. Was mache ich in C++?

Ich fühle mich wie die Antwort ist Vererbung, aber wenn sie alle einige Basisklasse sind, dann ruft es die Basisklasse weiter propagieren, nicht Kind.

Ich versuche, eine Redundanz zu vermeiden. Knoten wissen, welche Operation ihre Eingaben in Ausgaben umwandelt. Aber sie können Eingaben verschiedener Typen annehmen, solange sie dieselbe Form haben. IE, ein ElementwiseVectorDoubler-Knoten könnte als Eingabe dienen und jede Art von Knoten, der Vektoren handhabt, ausgeben. Könnte Eingabe von einer Matrix multiplizieren, etc ... Aber ich möchte nicht separate ElementwiseVectorDoubler-Klassen für jeden spezifischen Typ von 1D Vektor haben unsere Ausgabe eingeben müssen.

Answer 1

Beantwortet. Danke UnholySheep. Ich brauche nur virtuelle Funktionen. http://www.cplusplus.com/doc/tutorial/polymorphism/