def _buildStructure(self, inputdim, insize, inlayer, convSize, numFeatureMaps): #build layers outdim = insize - convSize + 1 hlayer = TanhLayer(outdim * outdim * numFeatureMaps, name='h') self.addModule(hlayer) outlayer = SigmoidLayer(outdim * outdim, name='out') self.addOutputModule(outlayer) # build shared weights convConns = [] for i in range(convSize): convConns.append(MotherConnection(convSize * numFeatureMaps * inputdim, name='conv' + str(i))) outConn = MotherConnection(numFeatureMaps) # establish the connections. for i in range(outdim): for j in range(outdim): offset = i * outdim + j outmod = ModuleSlice(hlayer, inSliceFrom=offset * numFeatureMaps, inSliceTo=(offset + 1) * numFeatureMaps, outSliceFrom=offset * numFeatureMaps, outSliceTo=(offset + 1) * numFeatureMaps) self.addConnection(SharedFullConnection(outConn, outmod, outlayer, outSliceFrom=offset, outSliceTo=offset + 1)) for k, mc in enumerate(convConns): offset = insize * (i + k) + j inmod = ModuleSlice(inlayer, outSliceFrom=offset * inputdim, outSliceTo=offset * inputdim + convSize * inputdim) self.addConnection(SharedFullConnection(mc, inmod, outmod))
def __init__(self, boardSize, convSize, numFeatureMaps, **args): inputdim = 2 FeedForwardNetwork.__init__(self, **args) inlayer = LinearLayer(inputdim * boardSize * boardSize, name='in') self.addInputModule(inlayer) # we need some treatment of the border too - thus we pad the direct board input. x = convSize / 2 insize = boardSize + 2 * x if convSize % 2 == 0: insize -= 1 paddedlayer = LinearLayer(inputdim * insize * insize, name='pad') self.addModule(paddedlayer) # we connect a bias to the padded-parts (with shared but trainable weights). bias = BiasUnit() self.addModule(bias) biasConn = MotherConnection(inputdim) paddable = [] if convSize % 2 == 0: xs = range(x) + range(insize - x + 1, insize) else: xs = range(x) + range(insize - x, insize) paddable.extend(crossproduct([range(insize), xs])) paddable.extend(crossproduct([xs, range(x, boardSize + x)])) for (i, j) in paddable: self.addConnection( SharedFullConnection(biasConn, bias, paddedlayer, outSliceFrom=(i * insize + j) * inputdim, outSliceTo=(i * insize + j + 1) * inputdim)) for i in range(boardSize): inmod = ModuleSlice(inlayer, outSliceFrom=i * boardSize * inputdim, outSliceTo=(i + 1) * boardSize * inputdim) outmod = ModuleSlice(paddedlayer, inSliceFrom=((i + x) * insize + x) * inputdim, inSliceTo=((i + x) * insize + x + boardSize) * inputdim) self.addConnection(IdentityConnection(inmod, outmod)) self._buildStructure(inputdim, insize, paddedlayer, convSize, numFeatureMaps) self.sortModules()
def slicer(): nbunits = reduce(lambda x, y: x * y, dimensions, 1) insize = layer.indim / nbunits outsize = layer.outdim / nbunits for index in range(nbunits): yield ModuleSlice(layer, insize * index, insize * (index + 1), outsize * index, outsize * (index + 1))
def stateSlice(self): """Return a moduleslice that wraps the state transfer part of the layer. """ return ModuleSlice(self, inSliceFrom=self.dim * (3 + self.dimensions), outSliceFrom=self.dim)
def meatSlice(self): """Return a moduleslice that wraps the meat part of the layer.""" return ModuleSlice(self, inSliceTo=self.dim * (3 + self.dimensions), outSliceTo=self.dim)
def __init__(self, R, P, T): """ FeedForwardNetworks are networks that do not work for sequential data. Every input is treated as independent of any previous or following inputs. """ self._ffn = FeedForwardNetwork() """ Input layer: R_iP_j (region i, product j) at times (t-T, .., t-1) T - time interval R - number of regions P - number of products RPT - dimensionality of input layer *** input SORTED in ORDER RPT *** """ dim = T * R * P inputL = LinearLayer(T, name="input layer") """ Layer 1: groups of neurons for R_iP_j k_1*R*P """ k1 = T / 25 h1 = k1 * R * P # weighted average hiddenL_1 = LinearLayer(h1, name="hidden layer 1 - R_iP_j") k2 = k1 / 2 h2 = k2 * (R + P) hiddenL_2 = TanhLayer(h2, name="hidden layer 2 - R_i, P_j") h3 = 2 * h2 hiddenL_3 = TanhLayer(h3, name="hidden layer 3 - random nodes") outputL = LinearLayer(R * P, "output layer") """ add layers to network """ self._ffn.addInputModule(inputL) self._ffn.addOutputModule(outputL) self._ffn.addModule(hiddenL_1) self._ffn.addModule(hiddenL_2) self._ffn.addModule(hiddenL_3) """ create connections between layers """ # INPUT => 1ST HIDDEN LAYER # T*k2 weights per slice # mother connection to hold shared weights mc1 = MotherConnection(T * k1, name="sharedConnection") # keep slice indices to check inSlices = dict() outSlices = dict() # keep slices to check inputSlices = dict() h1Slices = dict() # keep connections to check sharedConn = dict() for i in range(R * P): outSlices[i] = (i * T, (i + 1) * T - 1) inSlices[i] = (i * k1, (i + 1) * k1 - 1) print outSlices[i], inSlices[i] inputSlices[i] = ModuleSlice(inputL, inSliceFrom=outSlices[i][0], inSliceTo=outSlices[i][1], outSliceFrom=outSlices[i][0], outSliceTo=outSlices[i][1]) print inputSlices[i] h1Slices[i] = ModuleSlice(hiddenL_1, inSliceFrom=inSlices[i][0], inSliceTo=inSlices[i][1], outSliceFrom=inSlices[i][0], outSliceTo=inSlices[i][1]) print h1Slices[i] sharedConn[i] = SharedFullConnection(mc1, inputSlices[i], h1Slices[i]) #print sharedConn[i].params for conn in sharedConn.itervalues(): #print conn #print conn.params self._ffn.addConnection(conn) # 1ST HIDDEN LAYER => 2ND HIDDEN LAYER h2_inIndices = dict() h2_inSlices = dict() for i in range(R + P): h2_inIndices[i] = (k2 * i, k2 * (i + 1) - 1) print h2_inIndices[i] # no outSlices for h2 since it will be fully connected to h3 h2_inSlices[i] = ModuleSlice( hiddenL_2, inSliceFrom=h2_inIndices[i][0], inSliceTo=h2_inIndices[i][1] ) #, outSliceFrom=h2_inIndices[i][0], outSliceTo=h2_inIndices[i][1]) # link each R_iP_j h1Slice with R_i and P_j h2_inSlices respectively h1h2Conn = dict() # there are R*P h1 slices, take every P slices and link them to P_i rj = 0 pj = R - 1 for i in range(R * P): #print "before",rj, pj,i if i != 0 and i % P == 0: rj = rj + 1 pj = R else: pj = pj + 1 #print rj, pj print h1Slices[i], h2_inSlices[rj] h1h2Conn[i] = FullConnection(h1Slices[i], h2_inSlices[rj], name="h1_h2_" + str(i)) print h1Slices[i], h2_inSlices[pj] h1h2Conn[R * P + i] = FullConnection(h1Slices[i], h2_inSlices[pj], name="h1_h2_" + str(R * P + i)) for conn in h1h2Conn.itervalues(): print conn print conn.params self._ffn.addConnection(conn) """ CAREFUL: for test numbers only 3 params for each pair of connected slices although it should be 4*2=8?? # full connection between Region and State layer and random hidden layer self._ffn.addConnection(FullConnection(hiddenL_2, hiddenL_3)) # full connection from random to output layer self._ffn.addConnection(FullConnection(hiddenL_3, outputL)) """ self._ffn.sortModules()