if (current.isInputVertex()) { VertexIndices[] inputsTo = current.getOutputVertices(); INDArray input = inputs[current.getVertexIndex()]; layerActivations.put(current.getVertexName(), input); vertices[vIdx].setInput(vIdxInputNum, input.dup()); //TODO When to dup? if (current.hasLayer()) { Layer l = current.getLayer(); if (l instanceof RecurrentLayer) { out = ((RecurrentLayer) l).rnnActivateUsingStoredState(current.getInputs()[0], training, storeLastForTBPTT); } else if (l instanceof MultiLayerNetwork) { List<INDArray> temp = ((MultiLayerNetwork) l).rnnActivateUsingStoredState( current.getInputs()[0], training, storeLastForTBPTT); out = temp.get(temp.size() - 1); } else { out = current.doForward(training); layerActivations.put(current.getVertexName(), out); } else { out = current.doForward(training); VertexIndices[] outputsTo = current.getOutputVertices(); if (outputsTo != null) { for (VertexIndices v : outputsTo) {
/** * This method just makes sure there's no state preserved within layers */ protected void clearLayersStates() { for (int f = 0; f < layers.length; f++) { layers[f].setInput(null); } for (int f = 0; f < vertices.length; f++) { vertices[f].clearVertex(); } }
private void copyParamsFromSubsetGraphToOrig() { for (GraphVertex aVertex : unFrozenSubsetGraph.getVertices()) { if (!aVertex.hasLayer()) continue; origGraph.getVertex(aVertex.getVertexName()).getLayer().setParams(aVertex.getLayer().params()); } }
/** * Get the parameters for the ComputationGraph * * @param backwardOnly If true: backprop parameters only (i.e., no visible layer biases used in layerwise pretraining layers) */ public INDArray params(boolean backwardOnly) { if (backwardOnly) return flattenedParams; List<INDArray> list = new ArrayList<>(layers.length); for (int i = 0; i < topologicalOrder.length; i++) { if (!vertices[topologicalOrder[i]].hasLayer()) continue; Layer l = vertices[topologicalOrder[i]].getLayer(); INDArray layerParams = l.params(); if (layerParams != null) list.add(layerParams); //may be null: subsampling etc layers } return Nd4j.toFlattened('f', list); }
if (current.isInputVertex()) continue; //No op if (current.hasLayer() && current.getLayer() instanceof FrozenLayer) break; if (current.isOutputVertex()) { int thisOutputNumber = configuration.getNetworkOutputs().indexOf(current.getVertexName()); if (current.getLayer() instanceof IOutputLayer) { IOutputLayer outputLayer = (IOutputLayer) current.getLayer(); if ((externalEpsilons == null || externalEpsilons.length == 0) && labels[thisOutputNumber] != null) { throw new DL4JException("Layer \"" + current.getVertexName() + "\" of type " + current.getLayer().getClass().getSimpleName() + " is set as network output " + "(but isn't an IOutputLayer). Only IOutputLayer layers can be fit via backprop with" + " a labels array. "); current.setEpsilon(externalEpsilons[thisOutputNumber]); setVertexEpsilon[topologicalOrder[i]] = true; Pair<Gradient, INDArray[]> pair = current.doBackward(truncatedBPTT); INDArray[] epsilons = pair.getSecond(); VertexIndices[] inputVertices = current.getInputVertices(); for (VertexIndices v : inputVertices) {
if (applyFrozen && allFrozen.contains(gv.getVertexName())) { if (gv.hasLayer()) { org.deeplearning4j.nn.api.Layer l = gv.getLayer(); gv.setLayerAsFrozen(); for (int j = 0; j < layers.length; j++) { if (layers[j] == l) { layers[j] = gv.getLayer(); //Place the new frozen layer to replace the original layer break; VertexIndices[] inputs = gv.getInputVertices(); if (inputs != null && inputs.length > 0) { for (int j = 0; j < inputs.length; j++) { int inputVertexIdx = inputs[j].getVertexIndex(); String alsoFreeze = origGraph.getVertices()[inputVertexIdx].getVertexName(); allFrozen.add(alsoFreeze); if (gv.hasLayer()) { if (gv.getLayer() instanceof FrozenLayer) { allFrozen.add(gv.getVertexName()); VertexIndices[] inputs = gv.getInputVertices(); if (inputs != null && inputs.length > 0) { for (int j = 0; j < inputs.length; j++) { int inputVertexIdx = inputs[j].getVertexIndex(); String alsoFrozen = origGraph.getVertices()[inputVertexIdx].getVertexName(); allFrozen.add(alsoFrozen);
for (int v = 0; v < vertices.length; v++) { GraphVertex vertex = vertices[v]; VertexIndices[] indices = vertex.getInputVertices(); String inputName = cv.getVertexName(); LayerInfo info = model.getLayerInfoByName(vertex.getVertexName()); if (info == null) info = getLayerInfo(vertex.getLayer(), x, currentY, 121); info.setName(vertex.getVertexName()); if (vertex.getLayer() == null) { info.setLayerType(vertex.getClass().getSimpleName()); if (model.getLayerInfoByName(vertex.getVertexName()) == null) { x++; model.addLayer(info);
initializeParams); if (gv.hasLayer()) { numLayers++; Layer l = gv.getLayer(); tempLayerList.add(l); List<String> layerVariables = l.conf().variables(); if (layerVariables != null) { for (String s : layerVariables) { variables.add(gv.getVertexName() + "_" + s); verticesMap.put(gv.getVertexName(), gv); String vertexName = gv.getVertexName(); List<String> vertexInputNames; vertexInputNames = vertexInputs.get(vertexName); String vertexName = gv.getVertexName(); int vertexIndex = gv.getVertexIndex(); List<String> vertexInputNames; vertexInputNames = vertexInputs.get(vertexName); gv.setInputVertices(inputIndices); String vertexName = gv.getVertexName(); gv.setOutputVertices(outputIndices);
GraphVertex current = vertices[topologicalOrder[i]]; if (current.isInputVertex()) { INDArray fMask = featureMaskArrays[current.getVertexIndex()]; map.put(current.getVertexIndex(), new Pair<>(fMask, MaskState.Active)); } else { VertexIndices[] inputVertices = current.getInputVertices(); current.feedForwardMaskArrays(inputMasks, maskState, minibatchSize); map.put(topologicalOrder[i], outPair); Layer ol = v.getLayer(); ol.setMaskArray(labelMaskArrays[i]);
/** * Get a given layer by name. */ public Layer getLayer(String name) { return verticesMap.get(name).getLayer(); //TODO checks }
for (GraphVertex vertex : computationGraph.getVertices()) { if (vertex instanceof LayerVertex) { final int numParams = vertex.getLayer().numParams(); System.out.println("Number of parameters in layer " + vertex.getVertexName() + ": " + numParams); totalNumParams += numParams;
GraphVertex current = vertices[currVertexIdx]; String name = current.getVertexName(); String[] classNameArr = current.getClass().toString().split("\\."); String className = classNameArr[classNameArr.length - 1]; if (!current.isInputVertex()) { connections = configuration.getVertexInputs().get(name).toString(); String out = "-"; String paramShape = "-"; if (current.hasLayer()) { Layer currentLayer = ((LayerVertex) current).getLayer(); classNameArr = currentLayer.getClass().getName().split("\\.");
@Override public ComputationGraph clone() { ComputationGraph cg = new ComputationGraph(configuration.clone()); cg.init(params().dup(), false); if (solver != null) { //If solver is null: updater hasn't been initialized -> getUpdater call will force initialization, however ComputationGraphUpdater u = this.getUpdater(); INDArray updaterState = u.getStateViewArray(); if (updaterState != null) { cg.getUpdater().setStateViewArray(updaterState.dup()); } } cg.listeners = this.listeners; for (int i = 0; i < topologicalOrder.length; i++) { if (!vertices[topologicalOrder[i]].hasLayer()) continue; String layerName = vertices[topologicalOrder[i]].getVertexName(); if (getLayer(layerName) instanceof FrozenLayer) { cg.getVertex(layerName).setLayerAsFrozen(); } } return cg; }
if (!vertices[topologicalOrder[i]].hasLayer()) continue; org.deeplearning4j.nn.api.Layer layer = vertices[topologicalOrder[i]].getLayer(); String layerName = vertices[topologicalOrder[i]].getVertexName(); int range = layer.numParams(); if (range <= 0) if (allFrozen.contains(gv.getVertexName())) { if (gv.hasLayer()) { org.deeplearning4j.nn.api.Layer l = gv.getLayer(); gv.setLayerAsFrozen(); String layerName = gv.getVertexName(); LayerVertex currLayerVertex = (LayerVertex) newConfig.getVertices().get(layerName); Layer origLayerConf = currLayerVertex.getLayerConf().getLayer(); for (int j = 0; j < layers.length; j++) { if (layers[j] == l) { layers[j] = gv.getLayer(); //Place the new frozen layer to replace the original layer break; VertexIndices[] inputs = gv.getInputVertices(); if (inputs != null && inputs.length > 0) { for (int j = 0; j < inputs.length; j++) { int inputVertexIdx = inputs[j].getVertexIndex(); String alsoFreeze = vertices[inputVertexIdx].getVertexName(); allFrozen.add(alsoFreeze);
private void copyOrigParamsToSubsetGraph() { for (GraphVertex aVertex : unFrozenSubsetGraph.getVertices()) { if (!aVertex.hasLayer()) continue; aVertex.getLayer().setParams(origGraph.getLayer(aVertex.getVertexName()).params()); } }
for (int v = 0; v < vertices.length; v++) { GraphVertex vertex = vertices[v]; VertexIndices[] indices = vertex.getInputVertices(); String inputName = cv.getVertexName(); LayerInfo info = model.getLayerInfoByName(vertex.getVertexName()); if (info == null) info = getLayerInfo(vertex.getLayer(), x, currentY, 121); info.setName(vertex.getVertexName()); if (vertex.getLayer() == null) { info.setLayerType(vertex.getClass().getSimpleName()); if (model.getLayerInfoByName(vertex.getVertexName()) == null) { x++; model.addLayer(info);
@Override protected Layer[] getOrderedLayers() { if (orderedLayers != null) { return orderedLayers; } GraphVertex[] vertices = network.getVertices(); //In CompGraph: we need to know topological ordering, so we know how parameters are laid out in the 1d view arrays int[] topologicalOrdering = network.topologicalSortOrder(); Layer[] out = new Layer[network.getNumLayers()]; int j = 0; for (int i = 0; i < topologicalOrdering.length; i++) { GraphVertex currentVertex = vertices[topologicalOrdering[i]]; if (!currentVertex.hasLayer()) { continue; } out[j++] = currentVertex.getLayer(); } orderedLayers = out; return orderedLayers; }
/** * Get the state of the RNN layer, as used in {@link #rnnTimeStep(INDArray...)}. * * @param layerName name of the layer * @return Hidden state, or null if layer is not an RNN layer */ public Map<String, INDArray> rnnGetPreviousState(String layerName) { Layer l = verticesMap.get(layerName).getLayer(); if (l == null || !(l instanceof RecurrentLayer)) return null; return ((RecurrentLayer) l).rnnGetPreviousState(); }