/** * 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); }
String out = "-"; String paramShape = "-"; if (current.hasLayer()) { Layer currentLayer = ((LayerVertex) current).getLayer(); classNameArr = currentLayer.getClass().getName().split("\\.");
@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; }
private void copyOrigParamsToSubsetGraph() { for (GraphVertex aVertex : unFrozenSubsetGraph.getVertices()) { if (!aVertex.hasLayer()) continue; aVertex.getLayer().setParams(origGraph.getLayer(aVertex.getVertexName()).params()); } }
initBuilderIfReq(); if (origGraph.getVertex(layerName).hasLayer()) { if (!origGraph.getVertex(fanoutVertexName).hasLayer()) { throw new UnsupportedOperationException( "Cannot modify nOut of a layer vertex that feeds non-layer vertices. Use removeVertexKeepConnections followed by addVertex instead");
@Override public void setBackpropGradientsViewArray(INDArray gradient) { int paramsSoFar = 0; for (int i = 0; i < topologicalOrder.length; i++) { if (!vertices[topologicalOrder[i]].hasLayer()) continue; Layer layer = vertices[topologicalOrder[i]].getLayer(); int range = layer.numParams(); if (range <= 0) continue; //Some layers: no parameters (subsampling etc) layer.setBackpropGradientsViewArray(gradient.get(NDArrayIndex.point(0), NDArrayIndex.interval(paramsSoFar, paramsSoFar + range))); paramsSoFar += range; } }
private void copyParamsFromSubsetGraphToOrig() { for (GraphVertex aVertex : unFrozenSubsetGraph.getVertices()) { if (!aVertex.hasLayer()) continue; origGraph.getVertex(aVertex.getVertexName()).getLayer().setParams(aVertex.getLayer().params()); } }
initializeParams); if (gv.hasLayer()) { numLayers++; Layer l = gv.getLayer();
/** * Pretrain network with multiple inputs and/or outputs */ public void pretrain(MultiDataSetIterator iter) { if (!configuration.isPretrain()) return; if (flattenedGradients == null) { initGradientsView(); } //Assume here that all layers are pretrainable layers for (int i = 0; i < topologicalOrder.length; i++) { if (!vertices[i].hasLayer()) continue; if (vertices[i].getLayer() instanceof IOutputLayer) continue; //Don't pretrain output layer if (!vertices[i].getLayer().isPretrainLayer()) continue; //Skip layers that aren't pretrainable pretrainLayer(vertices[i].getVertexName(), iter); } }
if (current.hasLayer()) { Layer l = current.getLayer(); if (l instanceof RecurrentLayer) {
@Override public void setParams(INDArray params) { if (params == flattenedParams) return; //No op if (this.flattenedParams != null && this.flattenedParams.length() == params.length()) { this.flattenedParams.assign(params); return; } int idx = 0; for (int i = 0; i < topologicalOrder.length; i++) { if (!vertices[topologicalOrder[i]].hasLayer()) continue; Layer layer = vertices[topologicalOrder[i]].getLayer(); int range = layer.numParams(); if (range <= 0) continue; //Some layers: no parameters (subsampling etc) INDArray get = params.get(NDArrayIndex.point(0), NDArrayIndex.interval(idx, range + idx)); layer.setParams(get); idx += range; } }
throw new IllegalStateException("Invalid vertex name: " + layerName); if (!verticesMap.get(layerName).hasLayer()) {
@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; }
continue; //No op if (current.hasLayer() && current.getLayer() instanceof FrozenLayer) break;
if (current.hasLayer()) {